pi-openai-toolkit 0.7.2 → 0.9.0

package/src/compact-client.ts

@@ -1,5 +1,5 @@
 import { writeDebugArtifact } from "./debug";
-import { mergeProviderHeaders } from "./provider-headers";
+import { buildResponsesRequestHeaders } from "./responses-headers";
 import type { NativeCompactionRuntime } from "./runtime";
 import type { NativeCompactionRequestBody } from "./serializer";
 import type { ArtifactContext, CompactionConfig } from "./types";
@@ -112,57 +112,10 @@ export function extractCompactedSummaryText(output: readonly unknown[]): string
 	return joined.length > 0 ? joined : undefined;
 }
 
-function decodeJwtPayload(token: string): Record<string, unknown> | undefined {
-	const parts = token.split(".");
-	if (parts.length !== 3) {
-		return undefined;
-	}
-
-	try {
-		const payloadText = Buffer.from(parts[1]!, "base64url").toString("utf8");
-		const payload = JSON.parse(payloadText);
-		return isRecord(payload) ? payload : undefined;
-	} catch {
-		return undefined;
-	}
-}
-
-function extractCodexAccountId(token: string): string | undefined {
-	const payload = decodeJwtPayload(token);
-	const authClaims = payload?.["https://api.openai.com/auth"];
-	if (!isRecord(authClaims)) {
-		return undefined;
-	}
-
-	const accountId = authClaims.chatgpt_account_id;
-	return typeof accountId === "string" && accountId.trim().length > 0 ? accountId.trim() : undefined;
-}
-
-function buildCodexUserAgent(): string {
-	const platform = typeof process !== "undefined" ? process.platform : "browser";
-	const arch = typeof process !== "undefined" ? process.arch : "unknown";
-	return `pi (${platform}; ${arch})`;
-}
-
 function toHeaders(runtime: NativeCompactionRuntime): Record<string, string> {
-	const headers = new Headers(mergeProviderHeaders(runtime.currentModel.headers, runtime.headers));
-	headers.set("accept", JSON_CONTENT_TYPE);
-	headers.set("content-type", JSON_CONTENT_TYPE);
-	if (!headers.has("authorization")) {
-		headers.set("authorization", `Bearer ${runtime.apiKey}`);
-	}
-
-	if (runtime.api === "openai-codex-responses") {
-		const accountId = extractCodexAccountId(runtime.apiKey);
-		if (accountId) {
-			headers.set("chatgpt-account-id", accountId);
-		}
-		headers.set("originator", "pi");
-		headers.set("user-agent", buildCodexUserAgent());
-		headers.set("openai-beta", "responses=experimental");
-	}
-
-	return Object.fromEntries(headers.entries());
+	return Object.fromEntries(
+		buildResponsesRequestHeaders(runtime, { accept: JSON_CONTENT_TYPE }).entries(),
+	);
 }
 
 function writeCompactArtifact(

package/src/config.ts

@@ -6,12 +6,21 @@ import {
 	DEFAULT_COMPACTION_CONFIG,
 	DEFAULT_TOOLKIT_CONFIG,
 	DEFAULT_AUTO_COMPACTION_CONFIG,
+	DEFAULT_AUTO_MODE_CONFIG,
+	DEFAULT_IMAGE_GENERATION_CONFIG,
+	DEFAULT_NATIVE_FALLBACK_CONFIG,
 	DEFAULT_WEB_SEARCH_CONFIG,
 	RESPONSES_COMPACT_CAPABLE_APIS,
+	REVIEWER_TIMEOUT_MAX_MS,
+	REVIEWER_TIMEOUT_MIN_MS,
 	THINKING_LEVELS,
 	TOOLKIT_ID,
+	type AutoModeConfig,
+	type AutoModeGate,
 	type CompactionConfig,
+	type ImageGenerationConfig,
 	type LoadedToolkitConfig,
+	type NativeFallbackConfig,
 	type ToolkitConfig,
 	type WebSearchConfig,
 } from "./types";
@@ -19,13 +28,12 @@ import {
 export const CONFIG_DIR = path.join(os.homedir(), ".pi", "agent", "extensions", TOOLKIT_ID);
 export const CONFIG_PATH = path.join(CONFIG_DIR, "config.json");
 
-const TOP_LEVEL_FIELDS = new Set(["compaction", "webSearch"]);
+const TOP_LEVEL_FIELDS = new Set(["compaction", "webSearch", "imageGeneration", "autoMode"]);
 const COMPACTION_FIELDS = new Set([
 	"enabled",
 	"allowCompactionContinuityBreak",
 	"remoteCompactModel",
-	"model",
-	"thinkingLevel",
+	"nativeFallback",
 	"autoCompaction",
 	"responsesApis",
 	"notifyOnLoad",
@@ -35,8 +43,11 @@ const COMPACTION_FIELDS = new Set([
 	"redactSensitiveData",
 	"artifactRoot",
 ]);
+const NATIVE_FALLBACK_FIELDS = new Set(["enabled", "model", "thinkingLevel"]);
 const AUTO_COMPACTION_FIELDS = new Set(["enabled", "continuation", "unsupportedFallback", "reserveTokens"]);
 const WEB_SEARCH_FIELDS = new Set(["enabled", "models"]);
+const IMAGE_GENERATION_FIELDS = new Set(["enabled"]);
+const AUTO_MODE_FIELDS = new Set(["enabled", "models", "reviewerModel", "gate", "extraTools", "timeoutMs"]);
 
 function isRecord(value: unknown): value is Record<string, unknown> {
 	return !!value && typeof value === "object" && !Array.isArray(value);
@@ -172,7 +183,7 @@ function toSupportedApis(
 	return accepted;
 }
 
-function toModelAllowlist(value: unknown, fieldPath: string, warnings: string[]): string[] | undefined {
+function toStringList(value: unknown, fieldPath: string, warnings: string[]): string[] | undefined {
 	if (value === undefined) return undefined;
 	if (!Array.isArray(value) || value.some((item) => typeof item !== "string")) {
 		warnings.push(`Ignoring ${fieldPath}: expected a string array.`);
@@ -182,10 +193,34 @@ function toModelAllowlist(value: unknown, fieldPath: string, warnings: string[])
 	return [...new Set(value.map((entry) => entry.trim()).filter(Boolean))];
 }
 
+function toAutoModeGate(value: unknown, fieldPath: string, warnings: string[]): AutoModeGate | undefined {
+	if (value === undefined) return undefined;
+	if (value === "side-effect" || value === "all") return value;
+	warnings.push(`Ignoring ${fieldPath}: expected one of side-effect, all.`);
+	return undefined;
+}
+
+function toReviewerTimeoutMs(value: unknown, fieldPath: string, warnings: string[]): number | undefined {
+	if (value === undefined) return undefined;
+	if (
+		typeof value === "number" &&
+		Number.isInteger(value) &&
+		value >= REVIEWER_TIMEOUT_MIN_MS &&
+		value <= REVIEWER_TIMEOUT_MAX_MS
+	) {
+		return value;
+	}
+	warnings.push(
+		`Ignoring ${fieldPath}: expected an integer between ${REVIEWER_TIMEOUT_MIN_MS} and ${REVIEWER_TIMEOUT_MAX_MS} ms.`,
+	);
+	return undefined;
+}
+
 function cloneDefaults(): ToolkitConfig {
 	return {
 		compaction: {
 			...DEFAULT_COMPACTION_CONFIG,
+			nativeFallback: { ...DEFAULT_NATIVE_FALLBACK_CONFIG },
 			autoCompaction: { ...DEFAULT_AUTO_COMPACTION_CONFIG },
 			responsesApis: [...DEFAULT_COMPACTION_CONFIG.responsesApis],
 		},
@@ -193,9 +228,34 @@ function cloneDefaults(): ToolkitConfig {
 			...DEFAULT_WEB_SEARCH_CONFIG,
 			models: [...DEFAULT_WEB_SEARCH_CONFIG.models],
 		},
+		imageGeneration: { ...DEFAULT_IMAGE_GENERATION_CONFIG },
+		autoMode: {
+			...DEFAULT_AUTO_MODE_CONFIG,
+			models: [...DEFAULT_AUTO_MODE_CONFIG.models],
+			extraTools: [...DEFAULT_AUTO_MODE_CONFIG.extraTools],
+		},
 	};
 }
 
+function applyNativeFallbackConfig(
+	raw: Record<string, unknown>,
+	resolved: NativeFallbackConfig,
+	warnings: string[],
+): void {
+	warnUnknownFields(raw, NATIVE_FALLBACK_FIELDS, "compaction.nativeFallback", warnings);
+	resolved.enabled =
+		toBoolean(raw.enabled, "compaction.nativeFallback.enabled", warnings) ?? resolved.enabled;
+
+	const modelSpec = toModelSpec(raw.model, "compaction.nativeFallback.model", warnings);
+	if (modelSpec !== undefined) {
+		resolved.model = modelSpec === null ? undefined : modelSpec;
+	}
+
+	resolved.thinkingLevel =
+		toThinkingLevel(raw.thinkingLevel, "compaction.nativeFallback.thinkingLevel", warnings) ??
+		resolved.thinkingLevel;
+}
+
 function applyAutoCompactionConfig(
 	raw: Record<string, unknown>,
 	resolved: CompactionConfig["autoCompaction"],
@@ -258,14 +318,14 @@ function applyCompactionConfig(
 		resolved.remoteCompactModel = remoteCompactModelSpec === null ? undefined : remoteCompactModelSpec;
 	}
 
-	const modelSpec = toModelSpec(raw.model, "compaction.model", warnings);
-	if (modelSpec !== undefined) {
-		resolved.model = modelSpec === null ? undefined : modelSpec;
+	if (raw.nativeFallback !== undefined) {
+		if (isRecord(raw.nativeFallback)) {
+			applyNativeFallbackConfig(raw.nativeFallback, resolved.nativeFallback, warnings);
+		} else {
+			warnings.push("Ignoring compaction.nativeFallback: expected a JSON object.");
+		}
 	}
 
-	resolved.thinkingLevel =
-		toThinkingLevel(raw.thinkingLevel, "compaction.thinkingLevel", warnings) ?? resolved.thinkingLevel;
-
 	if (raw.autoCompaction !== undefined) {
 		if (isRecord(raw.autoCompaction)) {
 			applyAutoCompactionConfig(raw.autoCompaction, resolved.autoCompaction, warnings);
@@ -299,12 +359,53 @@ function applyWebSearchConfig(
 	warnUnknownFields(raw, WEB_SEARCH_FIELDS, "webSearch", warnings);
 	resolved.enabled = toBoolean(raw.enabled, "webSearch.enabled", warnings) ?? resolved.enabled;
 
-	const models = toModelAllowlist(raw.models, "webSearch.models", warnings);
+	const models = toStringList(raw.models, "webSearch.models", warnings);
 	if (models !== undefined) {
 		resolved.models = models;
 	}
 }
 
+function applyImageGenerationConfig(
+	raw: Record<string, unknown>,
+	resolved: ImageGenerationConfig,
+	warnings: string[],
+): void {
+	warnUnknownFields(raw, IMAGE_GENERATION_FIELDS, "imageGeneration", warnings);
+	resolved.enabled =
+		toBoolean(raw.enabled, "imageGeneration.enabled", warnings) ?? resolved.enabled;
+}
+
+function applyAutoModeConfig(
+	raw: Record<string, unknown>,
+	resolved: AutoModeConfig,
+	warnings: string[],
+): void {
+	warnUnknownFields(raw, AUTO_MODE_FIELDS, "autoMode", warnings);
+	resolved.enabled = toBoolean(raw.enabled, "autoMode.enabled", warnings) ?? resolved.enabled;
+
+	const models = toStringList(raw.models, "autoMode.models", warnings);
+	if (models !== undefined) {
+		resolved.models = models;
+	}
+
+	const reviewerModel = toModelSpec(raw.reviewerModel, "autoMode.reviewerModel", warnings);
+	if (reviewerModel !== undefined) {
+		resolved.reviewerModel = reviewerModel === null ? undefined : reviewerModel;
+	}
+
+	resolved.gate = toAutoModeGate(raw.gate, "autoMode.gate", warnings) ?? resolved.gate;
+
+	const extraTools = toStringList(raw.extraTools, "autoMode.extraTools", warnings);
+	if (extraTools !== undefined) {
+		resolved.extraTools = extraTools;
+	}
+
+	const timeoutMs = toReviewerTimeoutMs(raw.timeoutMs, "autoMode.timeoutMs", warnings);
+	if (timeoutMs !== undefined) {
+		resolved.timeoutMs = timeoutMs;
+	}
+}
+
 /**
  * Load the canonical toolkit config from
  * `~/.pi/agent/extensions/pi-openai-toolkit/config.json`.
@@ -335,6 +436,22 @@ export function loadToolkitConfig(configPath: string = CONFIG_PATH): LoadedToolk
 				warnings.push("Ignoring webSearch: expected a JSON object.");
 			}
 		}
+
+		if (raw.imageGeneration !== undefined) {
+			if (isRecord(raw.imageGeneration)) {
+				applyImageGenerationConfig(raw.imageGeneration, resolved.imageGeneration, warnings);
+			} else {
+				warnings.push("Ignoring imageGeneration: expected a JSON object.");
+			}
+		}
+
+		if (raw.autoMode !== undefined) {
+			if (isRecord(raw.autoMode)) {
+				applyAutoModeConfig(raw.autoMode, resolved.autoMode, warnings);
+			} else {
+				warnings.push("Ignoring autoMode: expected a JSON object.");
+			}
+		}
 	}
 
 	resolved.compaction.artifactRoot = resolveConfiguredPath(

package/src/extension-runtime.ts

@@ -316,6 +316,7 @@ async function handleSessionBeforeCompact(event: SessionBeforeCompactEvent, ctx:
 	}
 
 	// Branch 1: Responses-family APIs use remote_compaction_v2 on the normal Responses stream.
+	let remoteAttempted = false;
 	const resolution = await resolveRemoteCompactionExecution(
 		ctx,
 		{
@@ -325,6 +326,7 @@ async function handleSessionBeforeCompact(event: SessionBeforeCompactEvent, ctx:
 		config.remoteCompactModel,
 	);
 	if (resolution.ok) {
+		remoteAttempted = true;
 		const responsesOutcome = await runResponsesNativeCompact(event, ctx, config, resolution.execution);
 		if (responsesOutcome.outcome === "success") {
 			return { compaction: responsesOutcome.compaction };
@@ -357,8 +359,10 @@ async function handleSessionBeforeCompact(event: SessionBeforeCompactEvent, ctx:
 		}
 	}
 
-	// Branch 2: run pi's native compaction method with the configured model.
-	const fallback = await runNativeFallbackCompaction({ ctx, event, config });
+	// Branch 2: run pi's native compaction method. A failed remote request is compacted by the
+	// remote producer itself; a model that cannot use remote v2 at all uses nativeFallback.model.
+	const fallbackModelSpec = remoteAttempted ? config.remoteCompactModel : config.nativeFallback.model;
+	const fallback = await runNativeFallbackCompaction({ ctx, event, config, modelSpec: fallbackModelSpec });
 	if (fallback.ok) {
 		if (ctx.hasUI) {
 			ctx.ui.notify(
@@ -394,8 +398,12 @@ async function handleSessionBeforeCompact(event: SessionBeforeCompactEvent, ctx:
 		ctx,
 	);
 
-	// Intentional pi-default paths: no configured model, or it matches the current one.
-	if (fallback.reason !== "no-model-configured" && fallback.reason !== "same-as-current-model") {
+	// Intentional pi-default paths: feature disabled, nothing configured, or it matches the current one.
+	const intentionalSkip =
+		fallback.reason === "disabled" ||
+		fallback.reason === "no-model-configured" ||
+		fallback.reason === "same-as-current-model";
+	if (!intentionalSkip) {
 		notifyWarning(
 			ctx,
 			`compaction model "${fallback.modelSpec}" unusable (${fallback.reason}${fallback.errorMessage ? `: ${fallback.errorMessage}` : ""}); using pi's default compaction`,

package/src/image-generation/artifacts.ts

@@ -0,0 +1,237 @@
+import { constants as fsConstants } from "node:fs";
+import {
+	link,
+	mkdir,
+	open,
+	realpath,
+	stat,
+	unlink,
+} from "node:fs/promises";
+import { randomUUID } from "node:crypto";
+import {
+	basename,
+	dirname,
+	extname,
+	isAbsolute,
+	join,
+	relative,
+	resolve,
+	sep,
+} from "node:path";
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import {
+	MAX_IMAGE_PATH_CHARS,
+	ImageGenerationError,
+	sanitizeImageDiagnostic,
+} from "./types";
+
+export type ExplicitOutputPlan = {
+	path: string;
+};
+
+function isPathInsideOrEqual(root: string, candidate: string): boolean {
+	const rel = relative(root, candidate);
+	return rel === "" || (!rel.startsWith(`..${sep}`) && rel !== ".." && !isAbsolute(rel));
+}
+
+function sanitizePathPart(value: string, fallback: string): string {
+	const sanitized = value
+		.trim()
+		.replace(/[^A-Za-z0-9._-]+/g, "-")
+		.replace(/^[.-]+|[.-]+$/g, "")
+		.slice(0, 120);
+	return sanitized || fallback;
+}
+
+async function realDirectory(path: string): Promise<string> {
+	return realpath(path).catch(() => resolve(path));
+}
+
+async function resolveWriteTarget(candidate: string): Promise<string> {
+	const suffix: string[] = [];
+	let current = resolve(candidate);
+	while (true) {
+		try {
+			const info = await stat(current);
+			if (suffix.length > 0 && !info.isDirectory()) {
+				throw new ImageGenerationError(
+					"output-path-invalid",
+					`Output parent is not a directory: ${current}`,
+				);
+			}
+			const existing = await realpath(current);
+			return resolve(existing, ...suffix);
+		} catch (error) {
+			if (error instanceof ImageGenerationError) throw error;
+			if (
+				error &&
+				typeof error === "object" &&
+				"code" in error &&
+				error.code !== "ENOENT"
+			) {
+				throw new ImageGenerationError(
+					"output-path-invalid",
+					`Unable to inspect output path: ${candidate}`,
+				);
+			}
+			const parent = dirname(current);
+			if (parent === current) {
+				throw new ImageGenerationError(
+					"output-path-invalid",
+					`Unable to resolve output path: ${candidate}`,
+				);
+			}
+			suffix.unshift(basename(current));
+			current = parent;
+		}
+	}
+}
+
+function throwIfAborted(signal: AbortSignal | undefined): void {
+	if (signal?.aborted) {
+		throw new ImageGenerationError("aborted", "Image generation was cancelled.");
+	}
+}
+
+export function getGeneratedImagesRoot(agentDir: string): string {
+	return join(resolve(agentDir), "generated-images");
+}
+
+export async function prepareExplicitOutputPath(args: {
+	rawPath?: string;
+	agentDir: string;
+	ctx: Pick<ExtensionContext, "cwd" | "hasUI" | "isProjectTrusted" | "ui">;
+	signal?: AbortSignal;
+}): Promise<ExplicitOutputPlan | undefined> {
+	if (args.rawPath === undefined) return undefined;
+	const trimmed = args.rawPath.trim();
+	if (!trimmed || trimmed.length > MAX_IMAGE_PATH_CHARS || extname(trimmed).toLowerCase() !== ".png") {
+		throw new ImageGenerationError(
+			"output-path-invalid",
+			"outputPath must be a non-empty .png file path.",
+		);
+	}
+
+	throwIfAborted(args.signal);
+	const lexical = isAbsolute(trimmed) ? resolve(trimmed) : resolve(args.ctx.cwd, trimmed);
+	const target = await resolveWriteTarget(lexical);
+	const targetInfo = await stat(target).catch(() => undefined);
+	if (targetInfo) {
+		throw new ImageGenerationError(
+			"output-path-invalid",
+			`Output path already exists and will not be overwritten: ${target}`,
+		);
+	}
+
+	const [agentRoot, projectRoot] = await Promise.all([
+		realDirectory(args.agentDir),
+		realDirectory(args.ctx.cwd),
+	]);
+	if (isPathInsideOrEqual(agentRoot, target)) return { path: target };
+
+	if (isPathInsideOrEqual(projectRoot, target)) {
+		if (!args.ctx.isProjectTrusted()) {
+			throw new ImageGenerationError(
+				"output-path-invalid",
+				"Writing generated images inside an untrusted project is not allowed.",
+			);
+		}
+		return { path: target };
+	}
+
+	if (!args.ctx.hasUI) {
+		throw new ImageGenerationError(
+			"output-path-approval-required",
+			"Writing outside the Pi agent root or trusted project requires interactive approval.",
+		);
+	}
+	const approved = await args.ctx.ui.confirm(
+		"Write generated image outside safe roots?",
+		[
+			"The generated PNG will be copied to this external path without overwriting an existing file:",
+			"",
+			target,
+			"",
+			"Continue?",
+		].join("\n"),
+		{ signal: args.signal },
+	);
+	throwIfAborted(args.signal);
+	if (!approved) {
+		throw new ImageGenerationError("output-path-declined", "External output path was declined.");
+	}
+	return { path: target };
+}
+
+async function publishBytesNoOverwrite(bytes: Uint8Array, target: string): Promise<void> {
+	const parent = dirname(target);
+	await mkdir(parent, { recursive: true });
+	const tempPath = join(parent, `.${basename(target)}.${randomUUID()}.tmp`);
+	let handle: Awaited<ReturnType<typeof open>> | undefined;
+	try {
+		handle = await open(tempPath, fsConstants.O_CREAT | fsConstants.O_EXCL | fsConstants.O_WRONLY, 0o600);
+		await handle.writeFile(bytes);
+		await handle.sync();
+		await handle.close();
+		handle = undefined;
+		await link(tempPath, target);
+	} finally {
+		await handle?.close().catch(() => undefined);
+		await unlink(tempPath).catch(() => undefined);
+	}
+}
+
+function isAlreadyExistsError(error: unknown): boolean {
+	return !!error && typeof error === "object" && "code" in error && error.code === "EEXIST";
+}
+
+export async function saveCanonicalImage(args: {
+	bytes: Uint8Array;
+	agentDir: string;
+	sessionId: string;
+	imageCallId: string;
+}): Promise<string> {
+	const root = getGeneratedImagesRoot(args.agentDir);
+	const sessionPart = sanitizePathPart(args.sessionId, "session");
+	const imagePart = sanitizePathPart(args.imageCallId, "image_generation");
+	const directory = join(root, sessionPart);
+
+	for (let index = 1; index <= 1000; index += 1) {
+		const suffix = index === 1 ? "" : `-${index}`;
+		const target = join(directory, `${imagePart}${suffix}.png`);
+		try {
+			await publishBytesNoOverwrite(args.bytes, target);
+			return target;
+		} catch (error) {
+			if (isAlreadyExistsError(error)) continue;
+			throw new ImageGenerationError(
+				"artifact-write-failed",
+				sanitizeImageDiagnostic(
+					error instanceof Error ? error.message : error,
+					"Failed to persist the generated image artifact.",
+				),
+			);
+		}
+	}
+	throw new ImageGenerationError(
+		"artifact-write-failed",
+		"Failed to reserve a unique generated image artifact path.",
+	);
+}
+
+export async function copyImageToExplicitPath(args: {
+	bytes: Uint8Array;
+	plan: ExplicitOutputPlan;
+}): Promise<void> {
+	const currentTarget = await resolveWriteTarget(args.plan.path);
+	if (currentTarget !== args.plan.path) {
+		throw new Error("Output path changed after approval.");
+	}
+	await publishBytesNoOverwrite(args.bytes, args.plan.path);
+}
+
+export const _artifactTest = {
+	isPathInsideOrEqual,
+	publishBytesNoOverwrite,
+	resolveWriteTarget,
+};