pi-multimodal-proxy 1.19.1 → 1.20.0

package/CHANGELOG.md

@@ -4,6 +4,13 @@ All notable changes to this project will be documented in this file.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
+## [1.20.0] - 2026-10-02
+
+### Added
+
+- **`generate_image` tool (Pi ≥ 1.0, feature-detected)** — agent-facing image creation through `ModelRegistry.generateImages()` with the session's credentials and request-time auth; usage counts toward session cost. Parameters: `prompt` (1..4000 chars), optional `model` (`provider/model-id` of an image-generation model). Model resolution walks `getAvailableOfType("image")` (cached per session): without an override the first keyed image model wins; a mistyped override errors with recovery-style close matches and a malformed one gets the expected format (Pi 1.0 codemode-error philosophy). The prompt leaves only after the data-egress consent gate (`/multimodal-proxy consent yes` / `allowed-providers`). Results carry the generated image blocks (vision-capable base models see the pixels directly) plus a summary text naming each `image="<id>"` id, and an `outputSchema`-shaped `structuredContent` (provider, model, per-image id/mimeType/dimensions, `costUSD` when the provider reported usage; `usage` passed through on the tool result). Generated images are persisted in the per-session recall stores (`imageData`/`imageMeta`) with `generated-<hash8>.<ext>` filename hints, so the existing pipeline takes over: for text-only base models the `tool_result` hook auto-describes them via the vision model and appends `DescriptionEntry`s (making `#` recall work), and `analyze_image` can re-query or crop them by id regardless of base-model modality. Shares the per-turn tool-call budget with `analyze_image` (10/turn); annotated `readOnlyHint: false` (cost-incurring content creation) and namespaced `multimodal-proxy`. Registered only when the runtime exposes `generateImages` — pi < 1.0 never sees the tool.
+- Five new tests for `resolveImageGenModelChoice` (default-first, exact override, close-match suggestions on typos, expected-format error, actionable hint when nothing is keyed) — 512 total, all green.
+
 ## [1.19.1] - 2026-10-02
 
 ### Changed

package/README.md

@@ -8,10 +8,21 @@ When **video or audio files** are detected, they are routed to a **multimodal mo
 
 **YouTube links** are detected too: paste a URL (`youtube.com/watch?v=…`, `youtu.be/…`, `/shorts/…`, etc.) and the video is downloaded with [`yt-dlp`](https://github.com/yt-dlp/yt-dlp) and analyzed exactly like a local file.
 
+## What's new in 1.20.0
+
+Image generation, riding Pi 1.0's new `models.generateImages()` API:
+
+- **`generate_image` tool** — agent-facing image creation with the session's image-generation models (feature-detected; silently absent on pi < 1.0). Prompt leaves only after the data-egress consent gate; the call reports usage/cost through the normal session accounting.
+- **Generated images join the pipeline** — results return as image blocks (vision base models see the pixels) **and** are persisted in the recall stores, so a text-only base model gets an automatic vision-model description (same as any tool-returned image), `#` recall works once described, and `analyze_image` can re-query or crop them via their `image="<id>"` ids.
+- **Codemode-friendly** — `outputSchema`-shaped `structuredContent` (provider, model, per-image ids/dimensions, `costUSD`) so scripts consume results programmatically; leans into Pi 1.0's leaner codemode with a compact description and recovery-style errors (close-match model suggestions, expected `provider/model-id` format, actionable `pi --login` hint when nothing is keyed).
+- **Shared cost guard** — `generate_image` counts against the same per-turn tool-call budget as `analyze_image`.
+
 ## What's new in 1.19.0
 
 Deep integration with recent Pi releases (0.87 / 0.99):
 
+- **`generate_image` tool (Pi ≥ 1.0)** — the agent can now **create** images, not just understand them. Calls run through `models.generateImages()` with the session's credentials (usage counts toward session cost), the model defaults to the first keyed image-generation model (override per call with `model: "provider/model-id"`), results carry image blocks plus stable `image="<id>"` ids, and the existing pipeline takes over automatically: text-only base models get an auto-description via your vision model, and every generated image is recallable (`#`) and re-analyzable/croppable with `analyze_image` like any attachment. Data-egress consent gates the provider before the first call.
+- **Pi 1.0 alignment (1.19.1)** — leaner `analyze_image` description (~40% smaller — codemode lists tools under a 3000-token budget and drops what doesn't fit), recovery-style errors that name close matches (model typos, recall ids) and expected shapes (crops), and a dynamic implicit-vision-model fallback via `getAvailableOfType()` when the curated chain is entirely unkeyed.
 - **Virtual model — `Multimodal Auto`** (Pi ≥ 0.99, on by default): a new entry in `/model` that routes each request for you — turns whose pending input carries images go **natively** to your configured vision model (real pixels, no text fence), everything else stays on your base model (auto = whatever physical model handled the session before, or pin one with `/multimodal-proxy virtual-base`). Sticky routing keeps prompt caches valid within a turn; the footer shows the routed model and `/session` lists cost per physical model. Disable with `/multimodal-proxy virtual off`.
 - **`analyze_image` speaks the 0.99 tool API** — errors now surface as real tool errors (`isError`) instead of fake text, results carry a machine-readable `structuredContent` (analysis text, provider/model, latency, grounding format, per-image ids/dimensions/crop) so **codemode scripts** can consume them programmatically, and the tool is annotated (`readOnlyHint`) and namespaced (`multimodal-proxy`) for codemode listings.
 - **Model-aware upload downscale** (Pi ≥ 0.87) — when the configured vision model declares `inputLimits.images.resize` in its catalog entry, the proxy derives the downscale target, JPEG quality, and byte budget from it (tightening, never loosening, your `max-upload` settings). No more double-resizing against provider limits.

package/extensions/__tests__/internal.test.ts

@@ -81,6 +81,7 @@ import {
 	selectVisionModels,
 	closeMatches,
 	pickDynamicVisionCandidate,
+	resolveImageGenModelChoice,
 	splitSubcommand,
 	stripImagePaths,
 	stripMediaPaths,
@@ -436,6 +437,56 @@ describe("pickDynamicVisionCandidate", () => {
 	});
 });
 
+describe("resolveImageGenModelChoice", () => {
+	const available = [
+		{ provider: "openrouter", modelId: "gpt-image-1" },
+		{ provider: "openrouter", modelId: "flux-schnell" },
+		{ provider: "google", modelId: "imagen-4" },
+	];
+
+	it("defaults to the first available model without an override", () => {
+		assert.deepEqual(resolveImageGenModelChoice(undefined, available), {
+			ok: true,
+			provider: "openrouter",
+			modelId: "gpt-image-1",
+		});
+		assert.deepEqual(resolveImageGenModelChoice("", available), {
+			ok: true,
+			provider: "openrouter",
+			modelId: "gpt-image-1",
+		});
+	});
+
+	it("accepts an exact override", () => {
+		assert.deepEqual(resolveImageGenModelChoice("google/imagen-4", available), {
+			ok: true,
+			provider: "google",
+			modelId: "imagen-4",
+		});
+	});
+
+	it("mistyped overrides carry recovery-style close matches", () => {
+		const out = resolveImageGenModelChoice("openrouter/gpt-imge-1", available);
+		assert.equal(out.ok, false);
+		if (!out.ok) {
+			assert.match(out.error, /not found/);
+			assert.ok(out.suggestions.includes("openrouter/gpt-image-1"));
+		}
+	});
+
+	it("rejects malformed model strings with the expected format", () => {
+		const out = resolveImageGenModelChoice("no-slash", available);
+		assert.equal(out.ok, false);
+		if (!out.ok) assert.match(out.error, /Expected format: provider\/model-id/);
+	});
+
+	it("errors with an actionable hint when nothing is keyed", () => {
+		const out = resolveImageGenModelChoice(undefined, []);
+		assert.equal(out.ok, false);
+		if (!out.ok) assert.match(out.error, /pi --login/);
+	});
+});
+
 describe("sanitizeProviderHeaders", () => {
 	it("drops null deletion markers", () => {
 		assert.deepEqual(

package/extensions/internal.ts

@@ -2435,6 +2435,50 @@ export function pickDynamicVisionCandidate<T extends DynamicCandidateLike>(model
 	return vision.find((m) => CHEAP_MODEL_RE.test(m.modelId)) ?? vision[0];
 }
 
+/** Outcome of image-generation model resolution (generate_image tool). */
+export type ImageGenModelChoice =
+	| { ok: true; provider: string; modelId: string }
+	| { ok: false; error: string; suggestions: readonly string[] };
+
+/**
+ * Resolve the image-generation model for one `generate_image` call (Pi ≥ 1.0).
+ * An explicit `provider/model-id` override must match an available (keyed)
+ * image model exactly — otherwise the error carries recovery-style close
+ * matches. Without an override the first available model wins.
+ */
+export function resolveImageGenModelChoice(
+	override: string | undefined,
+	available: ReadonlyArray<{ provider: string; modelId: string }>,
+): ImageGenModelChoice {
+	const labels = available.map((m) => `${m.provider}/${m.modelId}`);
+	if (override === undefined || override === "") {
+		const first = available[0];
+		if (!first) {
+			return {
+				ok: false,
+				error: "no image-generation model is available (keyed) in this session — add a provider key (e.g. pi --login openrouter)",
+				suggestions: [],
+			};
+		}
+		return { ok: true, provider: first.provider, modelId: first.modelId };
+	}
+	const parsed = parseModelString(override);
+	if (!parsed) {
+		return {
+				ok: false,
+			error: `invalid model string "${override}". Expected format: provider/model-id`,
+			suggestions: [],
+		};
+	}
+	const exact = available.find((m) => m.provider === parsed.provider && m.modelId === parsed.modelId);
+	if (exact) return { ok: true, provider: exact.provider, modelId: exact.modelId };
+	return {
+		ok: false,
+		error: `model "${parsed.provider}/${parsed.modelId}" not found among available image-generation models`,
+		suggestions: closeMatches(`${parsed.provider}/${parsed.modelId}`, labels, 3),
+	};
+}
+
 export function shouldStripImages(config: VisionConfig, modelInput: readonly string[] | undefined): boolean {
 	if (config.mode === "off") return false;
 	if (config.mode === "always") return true;

package/extensions/vision-proxy.ts

@@ -284,6 +284,7 @@ import {
 	applyDefaultModelFallback,
 	closeMatches,
 	pickDynamicVisionCandidate,
+	resolveImageGenModelChoice,
 	DEFAULT_MODEL_FALLBACKS,
 	applyRecallCompletion,
 	buildRecallItems,
@@ -469,6 +470,52 @@ const TOOL_DESCRIPTION = [
 /** Maximum analyze_image tool calls per agent turn. Prevents cost runaway. */
 const MAX_TOOL_CALLS_PER_TURN = 10;
 
+/**
+ * generate_image parameters (Pi ≥ 1.0). Lean on purpose: pi 1.0's codemode
+ * lists tool declarations under a 3000-token inline budget.
+ */
+const GenerateImageParams = Type.Object({
+	prompt: Type.String({
+		description: "Required, non-empty, max 4000 chars. What to draw; include style and aspect-ratio cues the provider supports.",
+	}),
+	model: Type.Optional(
+		Type.String({
+			description: "Optional; provider/model-id of an image-generation model. Defaults to the first available (keyed) image model.",
+		}),
+	),
+	reason: Type.Optional(Type.String({ description: "Optional; logged for analytics only" })),
+});
+
+/**
+ * outputSchema of generate_image: codemode scripts receive this
+ * structuredContent instead of the text + image blocks.
+ */
+const GenerateImageOutput = Type.Object({
+	ok: Type.Boolean({ description: "Whether generation succeeded." }),
+	error: Type.Optional(Type.String({ description: "Failure message, present when ok is false." })),
+	provider: Type.Optional(Type.String({ description: "Provider that generated the images." })),
+	model: Type.Optional(Type.String({ description: "Model id that generated the images." })),
+	images: Type.Optional(
+		Type.Array(
+			Type.Object({
+				id: Type.String({ description: "Stable image id usable for recall (image=\"...\") and analyze_image." }),
+				mimeType: Type.String(),
+				width: Type.Optional(Type.Number()),
+				height: Type.Optional(Type.Number()),
+			}),
+		),
+	),
+	costUSD: Type.Optional(Type.Number({ description: "Reported generation cost, when the provider returned usage." })),
+});
+
+const GENERATE_IMAGE_DESCRIPTION = [
+	"Generate images with the session's image-generation models (Pi ≥ 1.0, request-time credentials).",
+	"",
+	"`prompt` describes what to draw; `model` optionally picks an image-generation model (provider/model-id — defaults to the first available).",
+	"Returns image blocks attached to this result plus stable `image=\"<id>\"` ids that analyze_image can re-analyze or crop like any other image.",
+	"Each call costs money — use it when the user asks for an image to be created, not speculatively.",
+].join("\n");
+
 /** Default tool-result cache size; resized to config.cacheSize on first use. */
 const DEFAULT_TOOL_CACHE_SIZE = 50;
 
@@ -508,6 +555,8 @@ interface SessionState {
 	keyProbe?: Map<string, boolean>;
 	/** Cached dynamic (registry-keyed) vision candidate; null = none or runtime without the API (Pi ≥ 1.0). */
 	dynamicVisionProbe?: { provider: string; modelId: string } | null;
+	/** Cached available (keyed) image-generation models (Pi ≥ 1.0). */
+	imageGenModels?: Array<{ provider: string; modelId: string }>;
 	/** Last implicit-default substitution already notified this session. */
 	notifiedDefaultSub?: string;
 	/**
@@ -1741,6 +1790,188 @@ function recallSuggestions(imageData: ImageDataStore, imageMeta: ImageMetaStore,
 	return closeMatches(query, candidates, limit);
 }
 
+/** Content block shapes a tool result may carry (text and/or image). */
+type ToolContentBlock = { type: "text"; text: string } | { type: "image"; data: string; mimeType: string };
+
+/** Structured outcome of one generate_image call (1.20.0). */
+interface GenerateImageOutcome {
+	content: ToolContentBlock[];
+	isError?: boolean;
+	structured?: Record<string, unknown>;
+	usage?: unknown;
+}
+
+/** Wrap a failure message as a GenerateImageOutcome. */
+function generationError(message: string): GenerateImageOutcome {
+	return { content: [{ type: "text", text: message }], isError: true, structured: { ok: false, error: message } };
+}
+
+/**
+ * Available (keyed) image-generation models via getAvailableOfType("image")
+ * (Pi ≥ 1.0, feature-detected). Cached per session; probe failures cache as
+ * an empty list so a transient error cannot wedge the tool.
+ */
+async function availableImageGenModels(ctx: ExtensionContext): Promise<Array<{ provider: string; modelId: string }>> {
+	const state = getSessionState(ctx);
+	if (state.imageGenModels) return state.imageGenModels;
+	let out: Array<{ provider: string; modelId: string }> = [];
+	const reg = ctx.modelRegistry as ModelRegistry & {
+		getAvailableOfType?: (type: string) => Promise<ReadonlyArray<unknown>>;
+	};
+	if (typeof reg.getAvailableOfType === "function") {
+		try {
+			const models = (await reg.getAvailableOfType("image")) as ReadonlyArray<{ provider?: unknown; id?: unknown }>;
+			out = models
+				.filter((m): m is { provider: string; id: string } => typeof m.provider === "string" && typeof m.id === "string")
+				.map((m) => ({ provider: m.provider, modelId: m.id }));
+		} catch {
+			out = [];
+		}
+	}
+	state.imageGenModels = out;
+	return out;
+}
+
+/** Minimal response shape of ModelRegistry.generateImages() (Pi ≥ 1.0). */
+interface GenerateImagesResponseLike {
+	output?: ReadonlyArray<{ type?: unknown; data?: unknown; mimeType?: unknown }>;
+	usage?: { costUSD?: unknown; inputTokens?: unknown; outputTokens?: unknown };
+	stopReason?: unknown;
+	errorMessage?: unknown;
+}
+
+/**
+ * Generate one or more images with the session's image-generation models
+ * (Pi ≥ 1.0 `models.generateImages()`): resolve the model (explicit override
+ * with recovery-style suggestions, else the first keyed image model), gate
+ * on data-egress consent (the prompt leaves), call the registry, and return
+ * image blocks the conversation can see. Generated images are persisted in
+ * the recall stores, so analyze_image (and `#` recall once described) work
+ * on them exactly like attached images — including when the base model sees
+ * the pixels directly and the tool_result auto-description path never fires.
+ */
+async function handleGenerateImage(
+	params: { prompt: string; model?: string; reason?: string },
+	ctx: ExtensionContext,
+	config: VisionConfig,
+): Promise<GenerateImageOutcome> {
+	const prompt = typeof params.prompt === "string" ? params.prompt.trim() : "";
+	if (!prompt) return generationError("Error: prompt is required and must be non-empty.");
+	if (prompt.length > 4000) return generationError("Error: prompt must be at most 4000 characters.");
+
+	// Resolve the image-generation model.
+	const available = await availableImageGenModels(ctx);
+	const choice = resolveImageGenModelChoice(params.model, available);
+	if (!choice.ok) {
+		return generationError(
+			`Error: ${choice.error}.` +
+				(choice.suggestions.length > 0 ? ` Close matches: ${choice.suggestions.join(", ")}.` : ""),
+		);
+	}
+
+	// Data-egress consent: the prompt leaves for the image provider.
+	const entries = ctx.sessionManager.getEntries();
+	if (!hasConsent(entries, choice.provider, config.allowedProviders, config.deniedProviders)) {
+		return generationError(
+			`Error: consent required before sending the prompt to ${choice.provider}. Please tell the user to run the following command and then retry:\n\n/multimodal-proxy consent yes\n\n(To pre-consent this provider permanently: /multimodal-proxy allowed-providers add ${choice.provider})`,
+		);
+	}
+
+	// Fetch the ImageModel object for the chosen pair (sync registry lookups).
+	const reg = ctx.modelRegistry as ModelRegistry & {
+		getModelsOfType?: (type: string) => ReadonlyArray<unknown>;
+		findOfType?: (type: string, provider: string, modelId: string) => unknown;
+		generateImages?: (
+			model: unknown,
+			context: { input: Array<{ type: "text"; text: string }> },
+			options?: { signal?: AbortSignal },
+		) => Promise<GenerateImagesResponseLike>;
+	};
+	if (typeof reg.generateImages !== "function") {
+		return generationError("Error: this pi runtime does not expose models.generateImages() (needs pi ≥ 1.0). Update pi.");
+	}
+	let imageModel: unknown;
+	if (typeof reg.getModelsOfType === "function") {
+		const all = reg.getModelsOfType("image") as ReadonlyArray<{ provider?: unknown; id?: unknown }>;
+		imageModel = all.find(
+				(m) =>
+					typeof m.provider === "string" &&
+					typeof m.id === "string" &&
+					m.provider === choice.provider &&
+					m.id === choice.modelId,
+		);
+	}
+	if (!imageModel && typeof reg.findOfType === "function") {
+		imageModel = reg.findOfType("image", choice.provider, choice.modelId);
+	}
+	if (!imageModel) {
+		return generationError(
+			`Error: image model "${choice.provider}/${choice.modelId}" could not be resolved in the registry.`,
+		);
+	}
+
+	let response: GenerateImagesResponseLike;
+	try {
+		response = await reg.generateImages(imageModel, { input: [{ type: "text", text: prompt }] }, { signal: ctx.signal });
+	} catch (err) {
+		return generationError(`Error: image generation failed: ${err instanceof Error ? err.message : String(err)}`);
+	}
+	if (response.stopReason === "aborted") return generationError("Error: generation was cancelled.");
+	if (response.stopReason === "error") {
+		return generationError(
+			`Error: image generation failed: ${typeof response.errorMessage === "string" ? response.errorMessage : "unknown provider error"}`,
+		);
+	}
+
+	const blocks = (response.output ?? []).filter(
+		(b): b is { type: "image"; data: string; mimeType: string } =>
+			b.type === "image" && typeof b.data === "string" && typeof b.mimeType === "string",
+	);
+	if (blocks.length === 0) {
+		return generationError(
+			"Error: the model returned no images (text-only response). Try a different prompt or model.",
+		);
+	}
+
+	// Persist recall data so analyze_image (and # recall, once a description
+	// exists) work on generated images even when the base model sees the
+	// pixels directly and the tool_result auto-description path never fires.
+	const { imageMeta, imageData } = getSessionState(ctx);
+	const structuredImages: Array<Record<string, unknown>> = [];
+	for (const b of blocks) {
+		const hash = hashImageData(b.data);
+		const ext = b.mimeType.split("/")[1]?.replace(/[^a-z0-9]/gi, "") || "png";
+		storeImageMeta(imageMeta, hash, b.data, `generated-${hash.slice(0, 8)}.${ext}`);
+		storeImageData(imageData, hash, b.data, b.mimeType);
+		const dims = imageMeta.get(hash);
+		structuredImages.push({
+			id: hash,
+			mimeType: b.mimeType,
+			...(dims ? { width: dims.width, height: dims.height } : {}),
+		});
+	}
+
+	const costUSD = typeof response.usage?.costUSD === "number" ? response.usage.costUSD : undefined;
+	const ids = structuredImages.map((i) => `image="${i.id}"`).join(", ");
+	const text =
+		`[generate_image] ${pluralImages(blocks.length)} generated via ${choice.provider}/${choice.modelId}` +
+		(ids ? ` (${ids})` : "") +
+		(costUSD !== undefined ? ` — cost $${costUSD.toFixed(4)}` : "") +
+		". The images are attached as image blocks; their ids can be re-analyzed or cropped with analyze_image.";
+
+	return {
+		content: [{ type: "text", text }, ...blocks],
+		structured: {
+			ok: true,
+			provider: choice.provider,
+			model: choice.modelId,
+			images: structuredImages,
+			...(costUSD !== undefined ? { costUSD } : {}),
+		},
+		...(response.usage ? { usage: response.usage } : {}),
+	};
+}
+
 /**
  * Answer a targeted analyze_image question about one or more images: resolve
  * references (session recall ids or file paths), validate and apply crops,
@@ -2105,6 +2336,7 @@ interface EditorAutocompleteProvider {
 
 export default function (pi: ExtensionAPI) {
 	let _toolRegistered = false;
+	let _generateToolRegistered = false;
 	let _autocompleteRegistered = false;
 
 	/**
@@ -2340,7 +2572,7 @@ export default function (pi: ExtensionAPI) {
 		});
 
 	/** Register or unregister the analyze_image tool based on config. */
-	function syncToolRegistration(config: VisionConfig) {
+	function syncToolRegistration(config: VisionConfig, runtimeCtx?: ExtensionContext) {
 		const shouldHaveTool = config.mode !== "off" && config.tool === "on";
 		if (shouldHaveTool && !_toolRegistered) {
 			pi.registerTool({
@@ -2403,6 +2635,82 @@ export default function (pi: ExtensionAPI) {
 			});
 			_toolRegistered = true;
 		}
+		// generate_image (Pi ≥ 1.0 only): registered alongside analyze_image
+		// when the runtime exposes ModelRegistry.generateImages; silently
+		// skipped on older hosts so the tool never appears there.
+		if (
+			shouldHaveTool &&
+			!_generateToolRegistered &&
+			runtimeCtx &&
+			typeof (runtimeCtx.modelRegistry as ModelRegistry & { generateImages?: unknown }).generateImages ===
+				"function"
+		) {
+			pi.registerTool({
+				name: "generate_image",
+				label: "Generate Image",
+				description: GENERATE_IMAGE_DESCRIPTION,
+				promptSnippet: "Generate images with the session's image-generation models",
+				promptGuidelines: [
+					"Use generate_image when the user explicitly asks to create an image; each call costs money.",
+					'Generated images carry image="<id>" ids and can be re-analyzed or cropped with analyze_image like any other image.',
+				],
+				// Cost-incurring content creation: not read-only. openWorldHint — the
+				// prompt leaves for the configured image provider.
+				annotations: {
+					readOnlyHint: false,
+					destructiveHint: false,
+					idempotentHint: false,
+					openWorldHint: true,
+				},
+				namespace: {
+					name: "multimodal-proxy",
+					description: "pi-multimodal-proxy media analysis (targeted image re-analysis with crop and grounding)",
+				},
+				outputSchema: GenerateImageOutput,
+				parameters: GenerateImageParams,
+				execute: async (_toolCallId, params, _signal, _onUpdate, extCtx) => {
+					const entries = extCtx.sessionManager.getEntries();
+					const config = await withModelFallback(resolveConfig(entries, process.env, _fileConfig), extCtx);
+
+					// Runtime check - tool may have been disabled mid-session
+					if (config.tool !== "on" || config.mode === "off") {
+						return {
+							content: [
+								{
+									type: "text" as const,
+									text: "Error: generate_image tool is currently disabled. Use /multimodal-proxy tool on to enable.",
+								},
+							],
+							isError: true,
+						};
+					}
+
+					// Share the per-turn cost-runaway budget with analyze_image.
+					const state = getSessionState(extCtx);
+					state.toolCallCount++;
+					if (state.toolCallCount > MAX_TOOL_CALLS_PER_TURN) {
+						return {
+							content: [
+								{
+									type: "text" as const,
+									text: `Error: tool call limit reached (${MAX_TOOL_CALLS_PER_TURN} per turn). Try again in the next turn.`,
+								},
+							],
+							isError: true,
+						};
+					}
+
+					const outcome = await handleGenerateImage(params, extCtx, config);
+					return {
+						content: outcome.content,
+						...(outcome.isError ? { isError: true } : {}),
+						...(outcome.structured ? { structuredContent: outcome.structured } : {}),
+						...(outcome.usage !== undefined ? { usage: outcome.usage } : {}),
+					};
+				},
+			});
+			_generateToolRegistered = true;
+		}
 		// Note: Pi's extension API doesn't have unregisterTool - tool registration
 		// persists for the session. The tool's execute handler checks the current
 		// config at runtime and returns an error if disabled.
@@ -2418,6 +2726,8 @@ export default function (pi: ExtensionAPI) {
 		clearImageData(state.imageData);
 		state.compaction = undefined;
 		state.keyProbe = undefined;
+		state.dynamicVisionProbe = undefined;
+		state.imageGenModels = undefined;
 		state.notifiedDefaultSub = undefined;
 
 		_fileConfig = await readPersistentFile();
@@ -2427,7 +2737,7 @@ export default function (pi: ExtensionAPI) {
 		ctx.ui.setStatus("multimodal-proxy", steadyStatusText(config, ctx.modelRegistry));
 
 		// Register tool if enabled
-		syncToolRegistration(config);
+		syncToolRegistration(config, ctx);
 
 		// Register the multimodal-proxy/auto virtual model (pi ≥ 0.99)
 		syncVirtualModelRegistration(config);
@@ -3319,7 +3629,7 @@ export default function (pi: ExtensionAPI) {
 					next.mode === "off" ? "warning" : "info",
 				);
 				// Sync tool registration on mode change
-				syncToolRegistration(resolveConfig(ctx.sessionManager.getEntries(), process.env, _fileConfig));
+				syncToolRegistration(resolveConfig(ctx.sessionManager.getEntries(), process.env, _fileConfig), ctx);
 				return;
 			}
 
@@ -3731,7 +4041,7 @@ Use "*" or "all" to grant consent for all providers globally.`,
 				}
 				if (valueLower === "on") {
 					const next = writePersisted({ ...persisted, tool: "on" });
-					syncToolRegistration(resolveConfig(ctx.sessionManager.getEntries(), process.env, _fileConfig));
+					syncToolRegistration(resolveConfig(ctx.sessionManager.getEntries(), process.env, _fileConfig), ctx);
 					ctx.ui.notify(`[multimodal-proxy] analyze_image tool: ON`, "info");
 					return;
 				}
@@ -4472,7 +4782,7 @@ Use "*" or "all" to grant consent for all providers globally.`,
 				if (modeChoice !== "fallback" && modeChoice !== "always" && modeChoice !== "off") return;
 				const next = writePersisted({ ...persisted, mode: modeChoice });
 				ctx.ui.notify(`Mode set to: ${next.mode}`, "info");
-				syncToolRegistration(resolveConfig(ctx.sessionManager.getEntries(), process.env, _fileConfig));
+				syncToolRegistration(resolveConfig(ctx.sessionManager.getEntries(), process.env, _fileConfig), ctx);
 				return;
 			}
 
@@ -4501,7 +4811,7 @@ Use "*" or "all" to grant consent for all providers globally.`,
 				}
 				const nextTool = effective.tool === "on" ? "off" : "on";
 				writePersisted({ ...persisted, tool: nextTool });
-				syncToolRegistration(resolveConfig(ctx.sessionManager.getEntries(), process.env, _fileConfig));
+				syncToolRegistration(resolveConfig(ctx.sessionManager.getEntries(), process.env, _fileConfig), ctx);
 				ctx.ui.notify(`Tool: ${nextTool}`, nextTool === "on" ? "info" : "warning");
 				return;
 			}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-multimodal-proxy",
-  "version": "1.19.1",
+  "version": "1.20.0",
   "description": "Automatic image, video and audio description for any model in Pi. Routes media to a multimodal model and injects descriptions into context.",
   "keywords": [
     "pi-package"