@oai404iao/pi-codex-imagegen 0.3.0 → 0.4.0

package/LICENSE

@@ -1,4 +1,4 @@
-Licensing for pi-codex-minimal-tools
+Licensing for pi-codex-imagegen
 
 Except for the third-party materials identified in THIRD_PARTY_NOTICES.md,
 the project-authored portions of this package are available under the

package/README.md

@@ -1,8 +1,22 @@
 # pi-codex-imagegen
 
-Alpha bootstrap candidate; initial npm publication is still pending.
+See the package guide below for release status; source edits do not publish artifacts.
 
-Peer floor: Pi 0.87.0; development target: 0.87.1.
+Peer floor and development target: Pi 0.99.1.
+
+Hosted generation is model-only, including with native codemode in `only` mode.
+Standalone generation remains directly callable and is also available to
+codemode while active. Exposure follows the selected model profile; this does
+not enable codemode itself. A hosted profile with explicit direct fallback
+remains model-only.
+
+Codemode scripts receive `{ path, latestPath?, image: { type, data, mimeType } }`.
+The image data is base64; use `image(result.image)` to forward it to the model.
+Saving and direct model-facing image/text output retain their existing behavior.
+Failed generation rejects the call instead of returning success-shaped data.
+Pi intentionally resolves retained structured data if a `tool_result` hook
+only sets `isError: true`. To reject or redact, that hook must also replace
+`content` without supplying `structuredContent`.
 
 `/image-gen` jobs are cancelled when the session is replaced or closed.
 Late authentication/results cannot notify the replacement session or initiate
@@ -17,6 +31,15 @@ fallback execution before authentication or network I/O.
 Catalog-supported standalone profiles call Images generation/edit endpoints with
 Pi authentication. Hosted profiles need core unless the existing
 `directImageApiFallback` option was explicitly enabled.
+All image paths, including this explicit fallback and background jobs, use
+the selected provider's Pi-resolved credentials, headers and base URL. The
+fallback no longer reads a separate `OPENAI_API_KEY` or forces the public
+OpenAI endpoint. Authentication failure never switches accounts or providers.
+`endpoint_config.imageGeneration` limits allowed modes at the authenticated
+endpoint. Rejected/denied standalone jobs do not fall through to hosted jobs.
+Explicit protocol rejection temporarily disables that mode for the session,
+including background jobs. With `codexRequestExtensions:false`, standalone
+requests omit generated Codex image-turn headers.
 
 Uses the existing
 `<agentDir>/extensions/pi-codex-minimal-tools/{config,models}.json` settings and
@@ -31,5 +54,12 @@ See [the package guide](../../docs/codex-packages.md). From repository root:
 
 ```bash
 npm run check -w @oai404iao/pi-codex-imagegen
+npm run test:codex-composition
 npm run test:codex-packages
 ```
+
+Client/capture/display/background-job regressions are in `tests/`; hosted
+transport integration is in root `tests/codex/`. See the
+[shared configuration guide](../pi-codex-runtime/reference/configuration.md) and
+[image-generation example](assets/image-generation.gif). The example is a
+repository asset, not part of the runtime tarball.

package/THIRD_PARTY_NOTICES.md

@@ -1,6 +1,6 @@
 # Source and license notices
 
-This unpublished package is split from `@oai404iao/pi-codex-minimal-tools`.
+This package owns image code split from `@oai404iao/pi-codex-minimal-tools`.
 Project material remains Copyright (c) 2026 oai404iao. The composite LICENSE
 and verified Apache license/NOTICE snapshots are retained.
 
@@ -14,4 +14,5 @@ claims that every referenced source file is shipped in this package.
 Endpoint clients and presentation code are project implementations. Protocol
 shapes are consumed from pi-codex-runtime rather than copied here.
 
-See the original package's reference/source-map.md for the pinned evidence map.
+See `pi-codex-runtime/reference/source-map.md` in the repository for the pinned
+evidence map and `reference/configuration.md` there for image configuration.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oai404iao/pi-codex-imagegen",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "private": false,
   "description": "Unpublished pi-codex-imagegen workspace for the staged Codex split",
   "type": "module",
@@ -28,9 +28,9 @@
     ]
   },
   "peerDependencies": {
-    "@earendil-works/pi-ai": ">=0.87.0",
-    "@earendil-works/pi-coding-agent": ">=0.87.0",
-    "@earendil-works/pi-tui": ">=0.87.0",
+    "@earendil-works/pi-ai": ">=0.99.1",
+    "@earendil-works/pi-coding-agent": ">=0.99.1",
+    "@earendil-works/pi-tui": ">=0.99.1",
     "typebox": "*"
   },
   "peerDependenciesMeta": {
@@ -45,12 +45,12 @@
     }
   },
   "dependencies": {
-    "@oai404iao/pi-codex-runtime": "0.4.0"
+    "@oai404iao/pi-codex-runtime": "0.5.0"
   },
   "devDependencies": {
-    "@earendil-works/pi-ai": "0.87.1",
-    "@earendil-works/pi-coding-agent": "0.87.1",
-    "@earendil-works/pi-tui": "0.87.1",
+    "@earendil-works/pi-ai": "0.99.1",
+    "@earendil-works/pi-coding-agent": "0.99.1",
+    "@earendil-works/pi-tui": "0.99.1",
     "@types/node": "^26.2.0",
     "tsx": "^4.20.6",
     "typebox": "^1.1.24",
@@ -77,5 +77,5 @@
   "engines": {
     "node": ">=22.19.0"
   },
-  "gitHead": "351c1943c7402b56f36abbe22fe45bb639bf5f81"
+  "gitHead": "8c96ca920ee51fe23c5c50d2cb2d8e1b304efe94"
 }

package/src/background-image-generation.ts

@@ -7,6 +7,9 @@ import { supportsImageInput, type ModelLike } from "@oai404iao/pi-codex-runtime/
 import {
 	buildCodexJsonHeaders,
 	hasCodexRequestAuth,
+	resolveResponsesUrl,
+	type ResponsesProtocol,
+	withResolvedAuthBaseUrl,
 } from "@oai404iao/pi-codex-runtime/internal/codex-http";
 import { createBackgroundImageJobs, panelBranch } from "./background-image-jobs.js";
 import { listResolvedModelProfiles } from "@oai404iao/pi-codex-runtime/internal/model-catalog/catalog";
@@ -20,8 +23,8 @@ import {
 } from "./tools/image-generation/storage.js";
 import { IMAGE_SAVE_DISPLAY_MESSAGE_TYPE, type SavedGeneratedImage } from "./tools/image-generation/types.js";
 import { projectRoot } from "./utils/images.js";
+import { checkEndpointResponse, rememberResolvedEndpoint, reportEndpointFailure, requireEndpointCapability } from "@oai404iao/pi-codex-runtime/internal/endpoint-state";
 
-const DEFAULT_CODEX_BASE_URL = "https://chatgpt.com/backend-api";
 const BACKGROUND_IMAGE_INSTRUCTIONS = "Generate or edit images with the hosted image_generation tool. Use the user's prompt and any provided reference images. Return the image_generation_call result.";
 const IMAGE_GEN_ERROR_MESSAGE_TYPE = "codex-image-generation-error";
 
@@ -81,15 +84,13 @@ function registryModels(registry: ModelRegistryLike | undefined): ModelLike[] {
 
 function isConfiguredImageModel(model: ModelLike | undefined): boolean {
 	if (!model || !supportsImageInput(model)) return false;
-	const settings = loadModelSettings(model);
-	return Boolean(
-		settings.modelProfile?.effective.enabled
-		&& settings.imageGenerationImplementation,
-	);
+	const settings = loadModelSettings({ ...model, baseUrl: undefined });
+	return Boolean(settings.modelProfile?.effective.enabled && settings.imageGenerationImplementation);
 }
 
 export function selectCodexImageModel(currentModel: ModelLike | undefined, registry: ModelRegistryLike | undefined): ModelLike | undefined {
-	if (isConfiguredImageModel(currentModel)) return currentModel;
+	const currentSettings = currentModel && loadModelSettings({ ...currentModel, baseUrl: undefined });
+	if (currentModel && supportsImageInput(currentModel) && currentSettings?.imageGenerationImplementation) return currentModel;
 	const discovered = registryModels(registry).find(isConfiguredImageModel);
 	if (discovered) return discovered;
 	for (const profile of listResolvedModelProfiles()) {
@@ -170,29 +171,19 @@ async function loadReferenceImage(cwd: string, rawPath: string): Promise<Referen
 	return { path, mimeType: mimeTypeForPath(path), base64: buffer.toString("base64") };
 }
 
-function resolveCodexUrl(baseUrl: string | undefined, options?: { apiKeyMode?: boolean }): string {
-	const raw = baseUrl && baseUrl.trim().length > 0 ? baseUrl : DEFAULT_CODEX_BASE_URL;
-	const normalized = raw.replace(/\/+$/, "");
-	if (options?.apiKeyMode) {
-		if (normalized.endsWith("/responses")) return normalized;
-		return `${normalized}/responses`;
-	}
-	if (normalized.endsWith("/codex/responses")) return normalized;
-	if (normalized.endsWith("/codex")) return `${normalized}/responses`;
-	return `${normalized}/codex/responses`;
-}
-
 function buildHeaders(
 	model: Model<Api>,
 	auth: { apiKey?: string; headers?: ProviderHeaders },
-	options?: { apiKeyMode?: boolean },
+	endpoint: ResponsesProtocol,
+	codexRequestExtensions: boolean,
 ): Headers {
 	const headers = buildCodexJsonHeaders({
 		modelHeaders: model.headers,
 		auth,
-		apiKeyMode: options?.apiKeyMode ?? false,
+		endpoint,
+		codexRequestExtensions,
 	});
-	setProviderGeneratedHeader(headers, "OpenAI-Beta", "responses=experimental");
+	if (codexRequestExtensions || endpoint === "codex") setProviderGeneratedHeader(headers, "OpenAI-Beta", "responses=experimental");
 	setProviderGeneratedHeader(headers, "accept", "text/event-stream");
 	return headers;
 }
@@ -323,7 +314,8 @@ async function runBackgroundImageGeneration(pi: ExtensionAPI, ctx: ExtensionComm
 	signal.throwIfAborted();
 	const model = selectCodexImageModel(ctx.model as ModelLike | undefined, ctx.modelRegistry as ModelRegistryLike | undefined) as Model<Api> | undefined;
 	if (!model) throw new Error("No image-capable model with an enabled model catalog profile is available.");
-	const settings = loadModelSettings(model as ModelLike, ctx.cwd);
+	const settings = loadModelSettings({ ...model, baseUrl: undefined }, ctx.cwd);
+	if (!settings.imageGenerationImplementation) throw new Error("Image generation is disabled for the selected model.");
 	if (!settings.enabled) throw new Error("pi-codex-minimal-tools is disabled.");
 	if (settings.imageGenerationImplementation === "standalone") {
 		const result = await standaloneImageGeneration({
@@ -333,6 +325,7 @@ async function runBackgroundImageGeneration(pi: ExtensionAPI, ctx: ExtensionComm
 			cwd: ctx.cwd,
 			model,
 			modelRegistry: ctx.modelRegistry,
+			sessionManager: ctx.sessionManager,
 		}, settings, signal, { callId: "standalone" });
 		signal.throwIfAborted();
 		const saved = result.details.saved;
@@ -364,6 +357,10 @@ async function runBackgroundImageGeneration(pi: ExtensionAPI, ctx: ExtensionComm
 	const auth = await ctx.modelRegistry.getApiKeyAndHeaders(model);
 	signal.throwIfAborted();
 	if (!auth.ok) throw new Error(auth.error);
+	const requestModel = withResolvedAuthBaseUrl(model, auth);
+	const sessionId = ctx.sessionManager.getSessionId();
+	rememberResolvedEndpoint(model, requestModel, sessionId);
+	requireEndpointCapability(settings.endpoint_config, requestModel, sessionId, "imageGeneration.hosted");
 	if (!hasCodexRequestAuth({
 		modelHeaders: model.headers,
 		auth: { apiKey: auth.apiKey, headers: auth.headers },
@@ -378,21 +375,24 @@ async function runBackgroundImageGeneration(pi: ExtensionAPI, ctx: ExtensionComm
 		responsesModel: model.id,
 		imageModel: settings.imageModel,
 	});
-	const response = await fetch(resolveCodexUrl(model.baseUrl, { apiKeyMode: settings.apiKeyMode }), {
+	const response = await fetch(resolveResponsesUrl(auth.baseUrl ?? model.baseUrl, settings.responsesEndpoint), {
 		signal,
 		method: "POST",
 		headers: buildHeaders(model, {
 			apiKey: auth.apiKey,
 			headers: auth.headers,
-		}, { apiKeyMode: settings.apiKeyMode }),
+		}, settings.responsesEndpoint, settings.codexRequestExtensions),
 		body: JSON.stringify(body),
 	});
 	signal.throwIfAborted();
-	if (!response.ok) throw new Error(`Codex image generation failed: ${response.status} ${await response.text()}`);
+	await checkEndpointResponse(response, requestModel, sessionId, ["imageGeneration.hosted"], signal);
 	const results: CodexImageResult[] = [];
 	let responseId: string | undefined;
 	let lastResponse: Record<string, unknown> | undefined;
 	for await (const event of parseSseEvents(response, signal)) {
+		if (event.type === "error" || event.type === "response.failed") {
+			reportEndpointFailure(requestModel, sessionId, ["imageGeneration.hosted"], event.error ?? (event.response as { error?: unknown } | undefined)?.error);
+		}
 		if (event.type === "response.created" && event.response && typeof event.response === "object") {
 			lastResponse = event.response as Record<string, unknown>;
 			const id = (event.response as { id?: unknown }).id;

package/src/index.ts

@@ -24,12 +24,15 @@ export default function codexImagegen(pi: ExtensionAPI): void {
 			return { createEventObserver: context => createImageCapture(context, sink) };
 		},
 	});
-	addPackageTool(broker, "image_generation", () => {
-		pi.registerTool(createImageGenerationToolDefinition({
-			loadSettings: (cwd, model) => loadModelSettings(model, cwd),
-			getCurrentTurnId: sessionId => currentCodexTurn(sessionId)?.turnId,
-			hasProviderRuntime: () => broker.coreEnabled,
-		}) as never);
+	const definition = createImageGenerationToolDefinition({
+		loadSettings: (cwd, model) => loadModelSettings(model, cwd),
+		getCurrentTurnId: sessionId => currentCodexTurn(sessionId)?.turnId,
+		hasProviderRuntime: () => broker.coreEnabled,
+	});
+	const parameters = { ...definition.parameters };
+	broker.ownedTools.set("image_generation", { parameters, description: definition.description });
+	addPackageTool(broker, "image_generation", exposure => {
+		pi.registerTool({ ...definition, parameters, exposure } as never);
 	});
 	registerBackgroundImageGenerationCommand(pi);
 }

package/src/tools/image-generation/output.ts

@@ -0,0 +1,29 @@
+import type { SavedImageInfo } from "../../utils/images.js";
+
+export const imageGenerationOutputSchema = {
+	type: "object",
+	additionalProperties: false,
+	required: ["path", "image"],
+	properties: {
+		path: { type: "string" },
+		latestPath: { type: "string" },
+		image: {
+			type: "object",
+			additionalProperties: false,
+			required: ["type", "data", "mimeType"],
+			properties: {
+				type: { type: "string", const: "image" },
+				data: { type: "string", description: "Base64 image data. Use image(result.image) to show it to the model." },
+				mimeType: { type: "string" },
+			},
+		},
+	},
+};
+
+export function imageGenerationOutput(saved: SavedImageInfo, base64: string) {
+	return {
+		path: saved.path,
+		...(saved.latestPath ? { latestPath: saved.latestPath } : {}),
+		image: { type: "image" as const, data: base64, mimeType: saved.mimeType },
+	};
+}

package/src/tools/image-generation.ts

@@ -3,14 +3,17 @@ import { readFile } from "node:fs/promises";
 import { extname, isAbsolute, resolve } from "node:path";
 import { buildSessionContext, type SessionEntry } from "@earendil-works/pi-coding-agent";
 import { saveBase64Image } from "../utils/images.js";
+import { imageGenerationOutput, imageGenerationOutputSchema } from "./image-generation/output.js";
 import type { CodexMinimalToolsSettings } from "@oai404iao/pi-codex-runtime/internal/settings";
 import type { Api, Model, ProviderHeaders } from "@earendil-works/pi-ai";
 import {
 	buildCodexJsonHeaders,
 	hasCodexRequestAuth,
 	resolveCodexApiEndpoint,
+	withResolvedAuthBaseUrl,
 } from "@oai404iao/pi-codex-runtime/internal/codex-http";
 import { loadModelSettings, type ResolvedCodexModelSettings } from "@oai404iao/pi-codex-runtime/internal/model-catalog/runtime";
+import { checkEndpointResponse, rememberResolvedEndpoint, requireEndpointCapability } from "@oai404iao/pi-codex-runtime/internal/endpoint-state";
 
 export interface ImageGenerationInput {
 	prompt?: string;
@@ -50,12 +53,24 @@ async function urlToBase64(url: string, signal?: AbortSignal): Promise<string> {
 	return buffer.toString("base64");
 }
 
-export async function directImageGeneration(input: ImageGenerationInput, cwd: string, settings: CodexMinimalToolsSettings, signal?: AbortSignal) {
+export async function directImageGeneration(input: ImageGenerationInput, ctx: ImageGenerationToolContext, settings: CodexMinimalToolsSettings, signal?: AbortSignal) {
 	if (!settings.imageGeneration) throw new Error("Image generation is disabled by the global imageGeneration setting.");
-	if (!settings.directImageApiFallback) throw new Error("Direct Images API fallback is disabled. Use native openai or openai-codex handling, or enable directImageApiFallback.");
-	const apiKey = process.env.OPENAI_API_KEY;
-	if (!apiKey) throw new Error("OPENAI_API_KEY is required for direct image_generation fallback.");
+	if (!settings.directImageApiFallback) throw new Error("Direct Images API fallback is disabled. Use the configured image implementation, or enable directImageApiFallback.");
 	if (!input.prompt?.trim()) throw new Error("A prompt is required for direct image_generation fallback.");
+	signal?.throwIfAborted();
+	const model = ctx.model;
+	if (!model || !ctx.modelRegistry) throw new Error("No active model is available for direct image generation.");
+	const auth = await ctx.modelRegistry.getApiKeyAndHeaders(model);
+	signal?.throwIfAborted();
+	if (!auth.ok) throw new Error(auth.error);
+	const requestModel = withResolvedAuthBaseUrl(model, auth);
+	const sessionId = ctx.sessionManager?.getSessionId?.();
+	rememberResolvedEndpoint(model, requestModel, sessionId);
+	requireEndpointCapability(settings.endpoint_config, requestModel, sessionId, "imageGeneration.standalone");
+	if (!hasCodexRequestAuth({ modelHeaders: model.headers, auth })) {
+		throw new Error(`No request authentication for provider: ${model.provider}`);
+	}
+	const endpoint = loadModelSettings(model, ctx.cwd, settings).responsesEndpoint;
 	const body: Record<string, unknown> = {
 		model: settings.imageModel,
 		prompt: input.prompt,
@@ -64,21 +79,23 @@ export async function directImageGeneration(input: ImageGenerationInput, cwd: st
 	if (input.quality && input.quality !== "auto") body.quality = input.quality;
 	if (input.background && input.background !== "auto") body.background = input.background;
 	if (input.output_format) body.output_format = input.output_format;
-	const response = await fetch("https://api.openai.com/v1/images/generations", {
+	const response = await fetch(resolveCodexApiEndpoint(auth.baseUrl ?? model.baseUrl, endpoint, "images/generations"), {
 		method: "POST",
-		headers: { Authorization: `Bearer ${apiKey}`, "content-type": "application/json" },
+		headers: buildCodexJsonHeaders({ modelHeaders: model.headers, auth, endpoint, codexRequestExtensions: settings.codexRequestExtensions }),
 		body: JSON.stringify(body),
 		signal,
 	});
-	if (!response.ok) throw new Error(`OpenAI Images API failed: ${response.status} ${await response.text()}`);
+	await checkEndpointResponse(response, requestModel, sessionId, ["imageGeneration.standalone"], signal);
 	const json = await response.json() as { data?: Array<{ b64_json?: string; url?: string; revised_prompt?: string }> };
 	const first = json.data?.[0];
 	const base64 = first?.b64_json ?? (first?.url ? await urlToBase64(first.url, signal) : undefined);
 	if (!base64) throw new Error("OpenAI Images API returned no image data.");
-	const saved = await saveBase64Image({ base64, callId: "direct", cwd, format: input.output_format, responseId: settings.imageModel, settings });
+	signal?.throwIfAborted();
+	const saved = await saveBase64Image({ base64, callId: "direct", cwd: ctx.cwd, format: input.output_format, responseId: settings.imageModel, settings });
 	return {
 		content: [{ type: "text", text: `Generated image with ${settings.imageModel}; saved to ${saved.path}${saved.latestPath ? ` (latest: ${saved.latestPath})` : ""}.` }],
 		details: { saved, revisedPrompt: first?.revised_prompt, mode: "direct-images-api" },
+		structuredContent: imageGenerationOutput(saved, base64),
 	};
 }
 
@@ -87,7 +104,7 @@ interface ImageGenerationToolContext {
 	model?: Model<Api>;
 	modelRegistry?: {
 		getApiKeyAndHeaders(model: Model<Api>): Promise<
-			| { ok: true; apiKey?: string; headers?: ProviderHeaders }
+			| { ok: true; apiKey?: string; headers?: ProviderHeaders; baseUrl?: string }
 			| { ok: false; error: string }
 		>;
 	};
@@ -183,6 +200,10 @@ export async function standaloneImageGeneration(
 	const auth = await ctx.modelRegistry.getApiKeyAndHeaders(model);
 	signal?.throwIfAborted();
 	if (!auth.ok) throw new Error(auth.error);
+	const requestModel = withResolvedAuthBaseUrl(model, auth);
+	const sessionId = ctx.sessionManager?.getSessionId?.();
+	rememberResolvedEndpoint(model, requestModel, sessionId);
+	requireEndpointCapability(settings.endpoint_config, requestModel, sessionId, "imageGeneration.standalone");
 	if (!hasCodexRequestAuth({
 		modelHeaders: model.headers,
 		auth: { apiKey: auth.apiKey, headers: auth.headers },
@@ -196,19 +217,20 @@ export async function standaloneImageGeneration(
 	signal?.throwIfAborted();
 	const response = await fetch(
 		resolveCodexApiEndpoint(
-			model.baseUrl,
-			settings.apiKeyMode,
+			auth.baseUrl ?? model.baseUrl,
+			settings.responsesEndpoint,
 			edit ? "images/edits" : "images/generations",
 		),
 		{
 			method: "POST",
 			headers: buildCodexJsonHeaders({
+				codexRequestExtensions: settings.codexRequestExtensions,
 				modelHeaders: model.headers,
 				auth: { apiKey: auth.apiKey, headers: auth.headers },
-				apiKeyMode: settings.apiKeyMode,
-				extraHeaders: {
+				endpoint: settings.responsesEndpoint,
+				extraHeaders: settings.codexRequestExtensions ? {
 					"x-codex-image-turn-id": turnId,
-				},
+				} : undefined,
 			}),
 			body: JSON.stringify({
 				model: settings.imageModel,
@@ -222,9 +244,7 @@ export async function standaloneImageGeneration(
 		},
 	);
 	signal?.throwIfAborted();
-	if (!response.ok) {
-		throw new Error(`Standalone image generation failed: HTTP ${response.status}: ${await response.text()}`);
-	}
+	await checkEndpointResponse(response, requestModel, sessionId, ["imageGeneration.standalone"], signal);
 	const result = await response.json() as {
 		data?: Array<{ b64_json?: string }>;
 	};
@@ -246,6 +266,7 @@ export async function standaloneImageGeneration(
 			{ type: "text", text: `Generated image with ${settings.imageModel}; saved to ${saved.path}${saved.latestPath ? ` (latest: ${saved.latestPath})` : ""}.` },
 		],
 		details: { saved, mode: "standalone-images-api" },
+		structuredContent: imageGenerationOutput(saved, base64),
 	};
 }
 
@@ -260,12 +281,14 @@ export function createImageGenerationToolDefinition(options: {
 		description: "Generate or edit images using the hosted or standalone implementation selected by the current model profile. Results are saved under imageOutputDir and mirrored to latest.<ext>.",
 		promptSnippet: "Generate or edit images with the implementation selected by the current model profile.",
 		parameters: imageGenerationToolSchema,
+		outputSchema: imageGenerationOutputSchema,
 		async execute(toolCallId: string, params: ImageGenerationInput, signal: AbortSignal | undefined, _onUpdate: unknown, ctx: ImageGenerationToolContext) {
 			const cwd = ctx?.cwd ?? process.cwd();
-			const settings = options.loadSettings?.(cwd, ctx.model) ?? loadModelSettings(ctx.model, cwd);
+			const profileModel = ctx.model ? { ...ctx.model, baseUrl: "" } : undefined;
+			const settings = options.loadSettings?.(cwd, profileModel) ?? loadModelSettings(profileModel, cwd);
 			const resolvedSettings = "modelProfile" in settings
 				? settings as ResolvedCodexModelSettings
-				: loadModelSettings(ctx.model, cwd, settings);
+				: loadModelSettings(profileModel, cwd, settings);
 			if (!resolvedSettings.imageGeneration) {
 				throw new Error("Image generation is disabled by the global setting or current model profile.");
 			}
@@ -276,12 +299,13 @@ export function createImageGenerationToolDefinition(options: {
 					turnId: options.getCurrentTurnId?.(sessionId),
 				});
 			}
-			if (settings?.directImageApiFallback) return directImageGeneration(params, cwd, settings, signal);
+			if (settings?.directImageApiFallback) return directImageGeneration(params, { ...ctx, cwd }, settings, signal);
 			if (options.hasProviderRuntime?.() === false) {
 				throw new Error("Hosted image_generation requires pi-codex-core. Use a catalog-supported standalone profile or explicitly enable directImageApiFallback.");
 			}
 			return {
-				content: [{ type: "text", text: "image_generation should be handled by the current model profile. If no hosted or standalone implementation is configured, enable directImageApiFallback with OPENAI_API_KEY." }],
+				isError: true,
+				content: [{ type: "text", text: "image_generation should be handled by the current model profile. If no hosted or standalone implementation is configured, explicitly enable directImageApiFallback using the current provider's Pi authentication." }],
 				details: { phase: "native-provider", nativeTool: "image_generation" },
 			};
 		},