pi-openai-toolkit 0.7.2 → 0.9.0

package/src/native-fallback.ts

@@ -12,6 +12,7 @@ import type { CompactionConfig } from "./types";
 export { parseModelSpec } from "./runtime";
 
 export type NativeFallbackFailureReason =
+	| "disabled"
 	| "no-model-configured"
 	| "invalid-model-spec"
 	| "model-not-found"
@@ -53,23 +54,35 @@ function toErrorMessage(error: unknown): string {
 }
 
 /**
- * Run pi's native compaction method with the user-configured compaction model.
+ * Run pi's native compaction method with a caller-resolved summary model.
  *
- * Only handles the "configured model differs from the current one" case: when no model
- * is configured (or it equals the current model), the caller should return undefined from
- * session_before_compact so pi runs the same native path itself, keeping its internal
+ * The two compaction chains stay separate: the caller passes `remoteCompactModel` only when a
+ * remote v2 request was actually attempted and failed, and `nativeFallback.model` only when the
+ * active model cannot use remote v2 at all. This function never inspects `remoteCompactModel`
+ * itself, so a model that cannot compact remotely can never inherit the remote producer.
+ *
+ * Only the "resolved model differs from the current one" case is handled here: when the feature
+ * is disabled, nothing is resolved, or it equals the current model, the caller returns undefined
+ * from session_before_compact so pi runs the same native path itself, keeping its internal
  * streamFn/thinkingLevel wiring.
  */
 export async function runNativeFallbackCompaction(args: {
 	ctx: ExtensionContext;
 	event: SessionBeforeCompactEvent;
 	config: CompactionConfig;
+	/** Model spec supplied by the caller for this specific fallback reason. */
+	modelSpec?: string;
 	compactFn?: NativeCompactFn;
 }): Promise<NativeFallbackResult> {
 	const { ctx, event, config } = args;
 	const compactFn = args.compactFn ?? compact;
+	const nativeFallback = config.nativeFallback;
+
+	if (!nativeFallback.enabled) {
+		return { ok: false, reason: "disabled" };
+	}
 
-	const spec = config.model?.trim();
+	const spec = args.modelSpec?.trim() ?? "";
 	if (!spec) {
 		return { ok: false, reason: "no-model-configured" };
 	}
@@ -106,7 +119,7 @@ export async function runNativeFallbackCompaction(args: {
 			mergeProviderHeaders(auth.headers),
 			event.customInstructions,
 			event.signal,
-			config.thinkingLevel,
+			nativeFallback.thinkingLevel,
 			undefined,
 			auth.env,
 		);

package/src/remote-v2-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, ResponsesInputItem } from "./serializer";
 import type { ArtifactContext, CompactionConfig } from "./types";
@@ -114,57 +114,13 @@ function normalizeResponseTimestamp(value: unknown): string | undefined {
 	return Number.isNaN(parsed) ? trimmed : new Date(parsed).toISOString();
 }
 
-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 isNonEmptyString(accountId) ? 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", SSE_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: SSE_CONTENT_TYPE,
+			contentType: JSON_CONTENT_TYPE,
+		}).entries(),
+	);
 }
 
 export function buildRemoteV2CompactionRequest(

package/src/responses-headers.ts

@@ -0,0 +1,67 @@
+import type { ProviderHeaders } from "@earendil-works/pi-ai";
+import { mergeProviderHeaders } from "./provider-headers";
+
+export type ResponsesHeaderRuntime = {
+	api: string;
+	apiKey: string;
+	headers?: ProviderHeaders;
+	currentModel: {
+		headers?: ProviderHeaders;
+	};
+};
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return !!value && typeof value === "object" && !Array.isArray(value);
+}
+
+function decodeJwtPayload(token: string): Record<string, unknown> | undefined {
+	const parts = token.split(".");
+	if (parts.length !== 3) return undefined;
+	try {
+		const payload = JSON.parse(Buffer.from(parts[1]!, "base64url").toString("utf8")) as unknown;
+		return isRecord(payload) ? payload : undefined;
+	} catch {
+		return undefined;
+	}
+}
+
+function extractCodexAccountId(token: string): string | undefined {
+	const authClaims = decodeJwtPayload(token)?.["https://api.openai.com/auth"];
+	if (!isRecord(authClaims)) return undefined;
+	const accountId = authClaims.chatgpt_account_id;
+	return typeof accountId === "string" && accountId.trim() ? 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})`;
+}
+
+export function buildResponsesRequestHeaders(
+	runtime: ResponsesHeaderRuntime,
+	options: { accept: string; contentType?: string },
+): Headers {
+	const headers = new Headers(
+		mergeProviderHeaders(runtime.currentModel.headers, runtime.headers),
+	);
+	headers.set("accept", options.accept);
+	headers.set("content-type", options.contentType ?? "application/json");
+	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 headers;
+}
+
+export const _responsesHeadersTest = {
+	extractCodexAccountId,
+};

package/src/runtime.ts

@@ -7,8 +7,9 @@ const CODEX_RESPONSES_PATH = "codex/responses";
 const OPENAI_COMPACT_PATH = "responses/compact";
 const CODEX_COMPACT_PATH = "codex/responses/compact";
 
-type ResponsesCompactApi = (typeof RESPONSES_COMPACT_CAPABLE_APIS)[number];
+export type ResponsesApi = (typeof RESPONSES_COMPACT_CAPABLE_APIS)[number];
 
+type ResponsesCompactApi = ResponsesApi;
 type RuntimeModel = Model<Api>;
 
 export type ParsedModelSpec = {
@@ -35,6 +36,8 @@ export type NativeCompactionSupportOptions = {
 	responsesApis?: readonly string[];
 };
 
+export type ResponsesSupportOptions = NativeCompactionSupportOptions;
+
 export type ResponsesCompatibleRequestPayload = {
 	model: string;
 	input: unknown[];
@@ -42,19 +45,22 @@ export type ResponsesCompatibleRequestPayload = {
 	[key: string]: unknown;
 };
 
-export type NativeCompactionRuntime = {
+export type ResponsesRuntime = {
 	provider: string;
-	api: ResponsesCompactApi;
+	api: ResponsesApi;
 	model: string;
 	baseUrl: string;
 	apiKey: string;
 	headers?: ProviderHeaders;
 	responsesPath: string;
 	responsesUrl: string;
+	currentModel: RuntimeModel;
+};
+
+export type NativeCompactionRuntime = ResponsesRuntime & {
 	compactPath: string;
 	compactUrl: string;
 	payload?: ResponsesCompatibleRequestPayload;
-	currentModel: RuntimeModel;
 };
 
 export type NativeCompactionEnvironmentFailure = {
@@ -77,6 +83,15 @@ export type NativeCompactionEnvironmentResolution =
 	| NativeCompactionEnvironmentFailure
 	| NativeCompactionEnvironmentSuccess;
 
+export type ResponsesEnvironmentSuccess = {
+	ok: true;
+	runtime: ResponsesRuntime;
+};
+
+export type ResponsesEnvironmentResolution =
+	| NativeCompactionEnvironmentFailure
+	| ResponsesEnvironmentSuccess;
+
 export type RemoteCompactionExecution = {
 	/** Active session model. Its identity owns replay matching and is never mutated. */
 	consumer: NativeCompactionRuntime;
@@ -327,6 +342,30 @@ async function resolveNativeCompactionEnvironmentForModel(
 	};
 }
 
+export async function resolveResponsesEnvironment(
+	ctx: ExtensionContext,
+	options: ResponsesSupportOptions = {},
+): Promise<ResponsesEnvironmentResolution> {
+	const resolution = await resolveNativeCompactionEnvironmentForModel(ctx, ctx.model, options);
+	if (!resolution.ok) return resolution;
+
+	const runtime = resolution.runtime;
+	return {
+		ok: true,
+		runtime: {
+			provider: runtime.provider,
+			api: runtime.api,
+			model: runtime.model,
+			baseUrl: runtime.baseUrl,
+			apiKey: runtime.apiKey,
+			headers: runtime.headers,
+			responsesPath: runtime.responsesPath,
+			responsesUrl: runtime.responsesUrl,
+			currentModel: runtime.currentModel,
+		},
+	};
+}
+
 export async function resolveNativeCompactionEnvironment(
 	ctx: ExtensionContext,
 	options: NativeCompactionSupportOptions = {},

package/src/types.ts

@@ -4,6 +4,8 @@ import type { CompactionEntry, CompactionResult, ExtensionContext, SessionEntry
 export const TOOLKIT_ID = "pi-openai-toolkit";
 export const COMPACTION_EXTENSION_ID = `${TOOLKIT_ID}:compaction`;
 export const WEB_SEARCH_EXTENSION_ID = `${TOOLKIT_ID}:web-search`;
+export const IMAGE_GENERATION_EXTENSION_ID = `${TOOLKIT_ID}:image-generation`;
+export const AUTO_MODE_EXTENSION_ID = `${TOOLKIT_ID}:auto-mode`;
 export const DEFAULT_ARTIFACT_ROOT = "~/.pi/agent/artifacts/pi-openai-toolkit/compaction";
 export const REDACTED_VALUE = "[REDACTED]";
 /**
@@ -38,6 +40,20 @@ export type DebugArtifactKind =
 
 export type CompactionContinuationMode = "inline" | "followUp" | "off";
 
+/** Native-method fallback compaction: which model runs pi's compact() and how deeply. */
+export type NativeFallbackConfig = {
+	enabled: boolean;
+	/**
+	 * "provider/model-id" used for native-method fallback compaction when the active model
+	 * cannot use remote v2 at all. A failed remote request is instead summarized by
+	 * `remoteCompactModel`; the two sources never substitute for each other. Unset means the
+	 * active model via pi's default path.
+	 */
+	model?: string;
+	/** Thinking level passed to pi's native compact() when the fallback model runs. */
+	thinkingLevel: ThinkingLevel;
+};
+
 export type AutoCompactionConfig = {
 	enabled: boolean;
 	continuation: CompactionContinuationMode;
@@ -57,13 +73,8 @@ export type CompactionConfig = {
 	 * remains the checkpoint consumer and continues handling normal requests.
 	 */
 	remoteCompactModel?: string;
-	/**
-	 * "provider/model-id" used for native-method fallback compaction (non-Responses APIs,
-	 * or when the compact endpoint fails). Unset = current model via pi's default path.
-	 */
-	model?: string;
-	/** Thinking level passed to pi's native compact() when the fallback model runs. */
-	thinkingLevel: ThinkingLevel;
+	/** Native-method fallback compaction policy (non-Responses APIs, or when the compact endpoint fails). */
+	nativeFallback: NativeFallbackConfig;
 	/** Threshold-triggered compaction and same-tool-loop continuation policy. */
 	autoCompaction: AutoCompactionConfig;
 	/** Subset of RESPONSES_COMPACT_CAPABLE_APIS that should use remote compaction. */
@@ -82,9 +93,34 @@ export type WebSearchConfig = {
 	models: string[];
 };
 
+export type ImageGenerationConfig = {
+	enabled: boolean;
+};
+
+/** `side-effect` reviews bash/write/edit plus extras; `all` reviews every tool call. */
+export type AutoModeGate = "side-effect" | "all";
+
+export type AutoModeConfig = {
+	enabled: boolean;
+	/** Exact provider/model keys whose sessions may engage auto mode. */
+	models: string[];
+	/** "provider/model-id" that approves gated tool calls while auto mode is engaged. */
+	reviewerModel?: string;
+	gate: AutoModeGate;
+	/** Extra tool names reviewed on top of the side-effect default set. */
+	extraTools: string[];
+	/** Reviewer deadline in ms; expiry degrades to human confirmation or fail-closed. */
+	timeoutMs: number;
+};
+
+export const REVIEWER_TIMEOUT_MIN_MS = 1_000;
+export const REVIEWER_TIMEOUT_MAX_MS = 120_000;
+
 export type ToolkitConfig = {
 	compaction: CompactionConfig;
 	webSearch: WebSearchConfig;
+	imageGeneration: ImageGenerationConfig;
+	autoMode: AutoModeConfig;
 };
 
 export type LoadedToolkitConfig = {
@@ -417,12 +453,17 @@ export const DEFAULT_AUTO_COMPACTION_CONFIG: AutoCompactionConfig = {
 	reserveTokens: undefined,
 };
 
+export const DEFAULT_NATIVE_FALLBACK_CONFIG: NativeFallbackConfig = {
+	enabled: true,
+	model: undefined,
+	thinkingLevel: "off",
+};
+
 export const DEFAULT_COMPACTION_CONFIG: CompactionConfig = {
 	enabled: true,
 	allowCompactionContinuityBreak: false,
 	remoteCompactModel: undefined,
-	model: undefined,
-	thinkingLevel: "off",
+	nativeFallback: { ...DEFAULT_NATIVE_FALLBACK_CONFIG },
 	autoCompaction: { ...DEFAULT_AUTO_COMPACTION_CONFIG },
 	responsesApis: [...RESPONSES_COMPACT_CAPABLE_APIS],
 	notifyOnLoad: false,
@@ -438,7 +479,22 @@ export const DEFAULT_WEB_SEARCH_CONFIG: WebSearchConfig = {
 	models: [],
 };
 
+export const DEFAULT_IMAGE_GENERATION_CONFIG: ImageGenerationConfig = {
+	enabled: false,
+};
+
+export const DEFAULT_AUTO_MODE_CONFIG: AutoModeConfig = {
+	enabled: true,
+	models: [],
+	reviewerModel: undefined,
+	gate: "side-effect",
+	extraTools: [],
+	timeoutMs: 30_000,
+};
+
 export const DEFAULT_TOOLKIT_CONFIG: ToolkitConfig = {
 	compaction: DEFAULT_COMPACTION_CONFIG,
 	webSearch: DEFAULT_WEB_SEARCH_CONFIG,
+	imageGeneration: DEFAULT_IMAGE_GENERATION_CONFIG,
+	autoMode: DEFAULT_AUTO_MODE_CONFIG,
 };

package/src/web-search/types.ts

@@ -1,3 +1,4 @@
+import { getExactModelKey, isExactModelAllowed } from "../model-scope";
 import type { WebSearchConfig } from "../types";
 
 export const WEB_SEARCH_CAPABLE_APIS = ["openai-responses", "openai-codex-responses"] as const;
@@ -28,20 +29,17 @@ export type WebSearchPayloadTransform = {
 };
 
 export function getWebSearchModelKey(model: WebSearchModel | undefined): string | undefined {
-	if (!model?.provider || !model.id) return undefined;
-	return `${model.provider}/${model.id}`;
+	return getExactModelKey(model);
 }
 
 export function isWebSearchEnabledForModel(
 	model: WebSearchModel | undefined,
 	config: WebSearchConfig,
 ): boolean {
-	const modelKey = getWebSearchModelKey(model);
 	return (
 		config.enabled &&
 		typeof model?.api === "string" &&
 		(WEB_SEARCH_CAPABLE_APIS as readonly string[]).includes(model.api) &&
-		modelKey !== undefined &&
-		config.models.includes(modelKey)
+		isExactModelAllowed(model, config.models)
 	);
 }

package/tsconfig.check.json

@@ -14,6 +14,8 @@
   "include": [
     "extensions/compaction.ts",
     "extensions/web-search.ts",
+    "extensions/image-generation.ts",
+    "extensions/auto-mode.ts",
     "src/compact-client.ts",
     "src/config.ts",
     "src/debug.ts",
@@ -21,9 +23,24 @@
     "src/deferred-tool-carryover.ts",
     "src/inline-compaction.ts",
     "src/extension-runtime.ts",
+    "src/image-generation/artifacts.ts",
+    "src/image-generation/client.ts",
+    "src/image-generation/eligibility.ts",
+    "src/image-generation/extension.ts",
+    "src/image-generation/protocol.ts",
+    "src/image-generation/references.ts",
+    "src/image-generation/render.ts",
+    "src/image-generation/service.ts",
+    "src/image-generation/types.ts",
+    "src/auto-mode/extension.ts",
+    "src/auto-mode/policy.ts",
+    "src/auto-mode/reviewer.ts",
+    "src/auto-mode/types.ts",
+    "src/model-scope.ts",
     "src/native-fallback.ts",
     "src/payload-rewrite.ts",
     "src/provider-headers.ts",
+    "src/responses-headers.ts",
     "src/remote-v2-client.ts",
     "src/request-context-cache.ts",
     "src/runtime.ts",