pi-openai-toolkit 0.14.13 → 0.15.0

package/src/image-generation/extension.ts

@@ -1,6 +1,7 @@
 import { StringEnum, Type, type Static } from "@earendil-works/pi-ai";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
-import { loadToolkitConfig } from "../config";
+import { loadToolkitConfig, resolveToolkitConfig } from "../config";
+import { notifyConfigIssues } from "../config/notifications";
 import { executeImageGeneration } from "./service";
 import { isImageGenerationEnabledForModel } from "./eligibility";
 import { renderImageGenerationResult } from "./render";
@@ -77,7 +78,7 @@ const GenerateImageParameters = Type.Object(
 				],
 				{
 					description:
-						"Use null to accept the default image model, which is the first entry of imageGeneration.models; otherwise provide another model id exactly as it appears in that configured list.",
+						"Use null to accept the default image model, configured by imageGeneration.defaultModel; otherwise provide another model id exactly as it appears in that configured list.",
 				},
 			),
 		),
@@ -115,14 +116,14 @@ export function registerImageGenerationExtension(
 		label: "OpenAI Generate Image",
 		description:
 			"Generate a PNG image, or edit from one to five user-approved local reference images, through the current Responses-capable model and a configured hosted image_generation model. This is a paid provider operation.",
-		promptSnippet: "Generate or edit PNG images through the current Responses-capable model and a configured imageGeneration.models entry.",
+		promptSnippet: "Generate or edit PNG images through the current Responses-capable model and a configured imageGeneration.allowedModels entry.",
 		promptGuidelines: [
 			"Use openai_generate_image when the user explicitly asks to create, draw, render, or edit a raster image and the active model speaks a Responses API.",
 			"Do not call openai_generate_image speculatively: it consumes the user's provider or gateway image quota.",
 			"Keep the image prompt faithful to the user's requested subject and constraints; do not invent unrequested style details.",
 			"Set referenceImagePaths to null unless the user explicitly identified local files; never invent paths or placeholder strings, and remember upload requires user approval.",
 			"Set outputPath to null unless the user explicitly asks for a destination; never invent a destination or placeholder string, and otherwise use the default Pi agent artifact.",
-			"Set model to null unless the user named an image model configured in imageGeneration.models; never invent or guess a model id, and remember an unlisted model fails before the paid request.",
+			"Set model to null unless the user named an image model configured in imageGeneration.allowedModels; never invent or guess a model id, and remember an unlisted model fails before the paid request.",
 			"Do not substitute Python, browser automation, shell scripts, or unrelated image tools for an eligible image request.",
 		],
 		parameters: GenerateImageParameters,
@@ -151,20 +152,15 @@ export function registerImageGenerationExtension(
 		renderResult: renderImageGenerationResult,
 	});
 
-	pi.on("session_start", (_event, ctx) => {
-		const { config } = loadConfig();
-		syncImageGenerationTool(pi, ctx.model, config.imageGeneration);
-	});
-
-	pi.on("model_select", (event) => {
-		const { config } = loadConfig();
-		syncImageGenerationTool(pi, event.model, config.imageGeneration);
-	});
-
-	pi.on("before_agent_start", (_event, ctx) => {
-		const { config } = loadConfig();
-		syncImageGenerationTool(pi, ctx.model, config.imageGeneration);
-	});
+	const synchronize = (ctx: Parameters<typeof executeImageGeneration>[0]["ctx"], model = ctx.model) => {
+		const resolved = resolveToolkitConfig(loadConfig(), model);
+		notifyConfigIssues(ctx, resolved);
+		const valid = !resolved.invalidFeatures.some((feature) => feature === "imageGeneration" || feature === "compatibility");
+		syncImageGenerationTool(pi, model, { ...resolved.config.imageGeneration, enabled: valid && resolved.policy.imageGeneration.enabled });
+	};
+	pi.on("session_start", (_event, ctx) => synchronize(ctx));
+	pi.on("model_select", (event, ctx) => synchronize(ctx, event.model));
+	pi.on("before_agent_start", (_event, ctx) => synchronize(ctx));
 }
 
 export default function imageGenerationExtension(pi: ExtensionAPI): void {

package/src/image-generation/protocol.ts

@@ -154,8 +154,8 @@ function usableImageModels(models: readonly string[] | undefined): string[] {
 
 /**
  * Resolve the nested `image_generation` model for one call. An omitted request selects the
- * first configured model so configuration order expresses the default; an explicit request must
- * match a configured id exactly, and it fails here — before any paid dispatch.
+ * explicit default when supplied (v2), or the first configured model for legacy callers.
+ * An explicit request must match a configured id exactly before any paid dispatch.
  */
 function formatAvailableImageModels(models: readonly string[]): string {
 	const visible = models.slice(0, MAX_DISPLAYED_IMAGE_MODELS_IN_ERROR);
@@ -166,15 +166,21 @@ function formatAvailableImageModels(models: readonly string[]): string {
 export function selectImageGenerationModel(args: {
 	requestedModel?: string;
 	configuredModels?: readonly string[];
+	defaultModel?: string;
 }): string {
 	const models = usableImageModels(args.configuredModels);
+	if (args.defaultModel !== undefined && (!args.configuredModels?.length ||
+		!args.configuredModels.every((model) => typeof model === "string" && model.trim().length > 0 && model.trim().length <= MAX_IMAGE_MODEL_ID_CHARS) ||
+		!models.includes(args.defaultModel))) {
+		throw new ImageGenerationError("invalid-parameters", "The configured default image model must be in the nonempty allowedModels list.");
+	}
 	const requested = typeof args.requestedModel === "string" ? args.requestedModel.trim() : "";
-	if (!requested) return models[0]!;
+	if (!requested) return args.defaultModel ?? models[0]!;
 	if (models.includes(requested)) return requested;
 	throw new ImageGenerationError(
 		"invalid-parameters",
 		`Unknown image generation model "${requested.slice(0, MAX_IMAGE_MODEL_ID_CHARS)}". ` +
-			`Configure it in imageGeneration.models first; available models: ${formatAvailableImageModels(models)}.`,
+			`Configure it in imageGeneration.allowedModels (legacy: imageGeneration.models) first; available models: ${formatAvailableImageModels(models)}.`,
 	);
 }
 

package/src/image-generation/service.ts

@@ -1,5 +1,6 @@
 import { getAgentDir, type ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { loadToolkitConfig } from "../config";
+import { assertConfigValid, loadToolkitConfig, resolveToolkitConfig } from "../config";
+import { notifyConfigIssues } from "../config/notifications";
 import { resolveResponsesEnvironment } from "../runtime";
 import {
 	copyImageToExplicitPath,
@@ -134,7 +135,10 @@ export function createImageGenerationExecutor(
 	return async (args) => {
 		const params = normalizeGenerateImageParams(args.params);
 		throwIfAborted(args.signal);
-		const { config } = deps.loadConfig();
+		const resolved = resolveToolkitConfig(deps.loadConfig(), args.ctx.model);
+		notifyConfigIssues(args.ctx, resolved);
+		assertConfigValid(resolved, "imageGeneration", "compatibility");
+		const { config } = resolved;
 		if (!isImageGenerationEnabledForModel(args.ctx.model, config.imageGeneration)) {
 			throw new ImageGenerationError(
 				"unsupported-model",
@@ -144,12 +148,14 @@ export function createImageGenerationExecutor(
 
 		const imageModel = selectImageGenerationModel({
 			requestedModel: params.model,
-			configuredModels: config.imageGeneration.models,
+			configuredModels: resolved.policy.imageGeneration.allowedModels,
+			defaultModel: resolved.policy.imageGeneration.defaultModel,
 		});
 
 		const runtimeResolution = await deps.resolveRuntime(args.ctx, {
 			enabled: config.imageGeneration.enabled,
 			responsesApis: IMAGE_GENERATION_CAPABLE_APIS,
+			...(resolved.format === "v2" ? { codexGatewayModels: resolved.gatewayModelKeys } : {}),
 		});
 		if (!runtimeResolution.ok) {
 			throw runtimeFailure(runtimeResolution.reason, runtimeResolution.errorMessage);

package/src/request-context-cache.ts

@@ -1,4 +1,5 @@
 import type { ResponsesCompatibleRequestPayload } from "./runtime";
+import { LOCAL_WEB_SEARCH_TOOL_NAME, WEB_RUN_TOOL_NAME } from "./web-search/types";
 
 /**
  * Explicit allowlist of fields mirrored from the latest live Responses request.
@@ -44,7 +45,7 @@ function isRecord(value: unknown): value is Record<string, unknown> {
 function isWebSearchTool(value: unknown): boolean {
 	if (!isRecord(value)) return false;
 	if (value.type === "web_search" || value.type === "web_search_preview") return true;
-	return value.type === "function" && (value.name === "web_search" || value.name === "web.run");
+	return value.type === "function" && (value.name === LOCAL_WEB_SEARCH_TOOL_NAME || value.name === WEB_RUN_TOOL_NAME);
 }
 
 function sameIdentity(cachedIdentity: RequestContextIdentity, current: RequestContextIdentity): boolean {