pi-openai-toolkit 0.23.2 → 0.24.0

package/src/native-fallback.ts

@@ -20,9 +20,7 @@ export type NativeFallbackFailureReason =
 	| "auth-failed"
 	| "aborted"
 	| "empty-summary"
-	| "compact-failed"
-	| "public-runtime-unavailable"
-	| "missing-model";
+	| "compact-failed";
 
 export type NativeFallbackResult =
 	| {
@@ -63,10 +61,8 @@ function toErrorMessage(error: unknown): string {
  * 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.
  *
- * Ordinary no-boundary defaults stay with Pi. When a window constrains input,
- * useCurrentModel runs the same public native primitive with the public registry
- * stream, current thinking and auth, rather than reopening unscoped host history.
- * Host-private custom stream/retry callbacks are not exposed by ExtensionContext.
+ * Unset or same-current-model defaults stay with Pi. This helper does not
+ * select a session model or take ownership of Pi's scheduler.
  */
 export async function runNativeFallbackCompaction(args: {
 	ctx: ExtensionContext;
@@ -75,10 +71,7 @@ export async function runNativeFallbackCompaction(args: {
 	/** Model spec supplied by the caller for this specific fallback reason. */
 	modelSpec?: string;
 	compactFn?: NativeCompactFn;
-	/** Scoped input cannot be handed back to an unscoped host default. */
-	scoped?: boolean;
-	/** Run current-model native policy, independently of Toolkit's fallback config. */
-	useCurrentModel?: boolean;
+	/** Reject results if the originating session/branch/selection changed. */
 	isCurrent?: () => boolean;
 }): Promise<NativeFallbackResult> {
 	const { ctx, event, config } = args;
@@ -87,21 +80,16 @@ export async function runNativeFallbackCompaction(args: {
 	const isCurrent = () => !event.signal.aborted && (args.isCurrent?.() ?? true);
 	if (!isCurrent()) return { ok: false, reason: "aborted" };
 
-	if (!args.useCurrentModel && !nativeFallback.enabled) return { ok: false, reason: "disabled" };
-	const spec = args.useCurrentModel ? (ctx.model ? `${ctx.model.provider}/${ctx.model.id}` : "") : args.modelSpec?.trim() ?? "";
-	if (!spec) return { ok: false, reason: args.useCurrentModel ? "missing-model" : "no-model-configured" };
+	if (!nativeFallback.enabled) return { ok: false, reason: "disabled" };
+	const spec = args.modelSpec?.trim() ?? "";
+	if (!spec) return { ok: false, reason: "no-model-configured" };
 	const parsed = parseModelSpec(spec);
 	if (!parsed) return { ok: false, reason: "invalid-model-spec", modelSpec: spec };
-	const model = args.useCurrentModel ? ctx.model : ctx.modelRegistry.find(parsed.provider, parsed.modelId);
+	const model = ctx.modelRegistry.find(parsed.provider, parsed.modelId);
 	if (!model) return { ok: false, reason: "model-not-found", modelSpec: spec };
-	if (!args.useCurrentModel && ctx.model && ctx.model.provider === model.provider && ctx.model.id === model.id) {
+	if (ctx.model && ctx.model.provider === model.provider && ctx.model.id === model.id) {
 		return { ok: false, reason: "same-as-current-model", modelSpec: spec };
 	}
-	// The public registry preserves provider-native stream/auth wiring. Do not
-	// silently use a compat-only transport for scoped current-model compression.
-	if (args.scoped && typeof ctx.modelRegistry.streamSimple !== "function" && !args.compactFn) {
-		return { ok: false, reason: "public-runtime-unavailable", modelSpec: spec };
-	}
 
 	// Pi owns prompt construction, tool-result truncation and split-turn requests.
 	// A chars/4 estimate is not target-model token accounting and must not veto
@@ -126,8 +114,8 @@ export async function runNativeFallbackCompaction(args: {
 			mergeProviderHeaders(auth.headers),
 			event.customInstructions,
 			event.signal,
-			args.useCurrentModel ? ctx.thinkingLevel : nativeFallback.thinkingLevel,
-			args.scoped && typeof ctx.modelRegistry.streamSimple === "function" ? ctx.modelRegistry.streamSimple.bind(ctx.modelRegistry) : undefined,
+			nativeFallback.thinkingLevel,
+			undefined,
 			auth.env,
 		);
 

package/src/responses-headers.ts

@@ -91,7 +91,7 @@ export function buildCodexCliUserAgent(version: string): string {
 
 /**
  * Codex client identity used by synthetic gateway requests in their User-Agent.
- * Native live and context-management requests do not generate a `version`
+ * Native live and shared synthetic requests do not generate a `version`
  * header; explicitly configured provider values remain caller-owned.
  */
 export const CODEX_CLIENT_VERSION = "0.153.0";

package/src/retired-remote-windows.ts

@@ -0,0 +1,35 @@
+/** Reserved persisted identifiers, retained only to refuse retired sessions. */
+export const RETIRED_REMOTE_WINDOW_TYPE = "codex-context-window" as const;
+export const RETIRED_MANUAL_COMPACT_TYPE = "pi-openai-toolkit:manual-compact" as const;
+export const RETIRED_REMOTE_WINDOW_SUMMARY =
+	"[Pi Codex context-window boundary; no conversation summary was generated.]";
+
+export type RetiredRemoteWindowsReason =
+	| "window-message"
+	| "window-compaction"
+	| "window-summary"
+	| "manual-compact-record";
+
+export const RETIRED_REMOTE_WINDOWS_MESSAGE =
+	"Remote Windows has been removed. This branch contains retired window or manual-compaction records and cannot continue. Start a new session and explicitly choose the model you want to use. Existing history is unchanged; no model or thinking level was restored.";
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+	return !!value && typeof value === "object" && !Array.isArray(value);
+}
+
+/**
+ * Inspect only the supplied active branch. Reserved identifiers suffice even
+ * when their data is damaged, terminal or superseded by a newer checkpoint.
+ * This deliberately interprets no ownership, recovery or migration state.
+ */
+export function detectRetiredRemoteWindows(entries: readonly unknown[]): RetiredRemoteWindowsReason | undefined {
+	for (const entry of entries) {
+		if (!isRecord(entry)) continue;
+		if (entry.type === "custom_message" && entry.customType === RETIRED_REMOTE_WINDOW_TYPE) return "window-message";
+		if (entry.type === "custom" && entry.customType === RETIRED_MANUAL_COMPACT_TYPE) return "manual-compact-record";
+		if (entry.type !== "compaction") continue;
+		if (isRecord(entry.details) && entry.details.strategy === RETIRED_REMOTE_WINDOW_TYPE) return "window-compaction";
+		if (entry.summary === RETIRED_REMOTE_WINDOW_SUMMARY) return "window-summary";
+	}
+	return undefined;
+}

package/src/runtime.ts

@@ -784,7 +784,8 @@ export async function resolveRemoteCompactionExecution(
 	options: NativeCompactionSupportOptions = {},
 	remoteModelSpec?: string,
 ): Promise<RemoteCompactionExecutionResolution> {
-	const consumerResolution = await resolveNativeCompactionEnvironment(ctx, options);
+	const selectedModel = ctx.model;
+	const consumerResolution = await resolveNativeCompactionEnvironmentForModel(ctx, selectedModel, options);
 	if (!consumerResolution.ok) {
 		return consumerResolution;
 	}
@@ -809,6 +810,16 @@ export async function resolveRemoteCompactionExecution(
 		};
 	}
 
+	const consumer = consumerResolution.runtime;
+	const matches = (model: { provider: string; id: string } | undefined) =>
+		model?.provider === parsed.provider && model.id === parsed.modelId;
+	// Reuse this operation's physical/auth snapshot for either the current
+	// logical selection or its resolved physical identity. Do not resolve a
+	// virtual selection again or look up/authenticate an identical producer.
+	if (matches(selectedModel) || matches(consumer.currentModel)) {
+		return { ok: true, execution: { consumer, compactor: consumer } };
+	}
+
 	const compactorModel = ctx.modelRegistry.find(parsed.provider, parsed.modelId);
 	if (!compactorModel) {
 		return {
@@ -832,7 +843,6 @@ export async function resolveRemoteCompactionExecution(
 		};
 	}
 
-	const consumer = consumerResolution.runtime;
 	const compactor = compactorResolution.runtime;
 	if (compactor.baseUrl !== consumer.baseUrl) {
 		return {

package/src/types.ts

@@ -19,8 +19,8 @@ export const RESPONSES_COMPACT_CAPABLE_APIS = [
 ] as const;
 /**
  * Bare model ID used by the independent Astra effort compatibility layer.
- * Remote Context eligibility is API/provider based with an exact gateway opt-in;
- * this constant does not verify backend support or grant that opt-in.
+ * Gateway transport is an independent exact-model opt-in; this constant
+ * does not verify backend support or grant that opt-in.
  */
 export const ASTRA_MODEL_ID = "gpt-6-astra";
 export const LEGACY_NATIVE_COMPACTION_STRATEGY = "openai-native-compact-v1";
@@ -60,8 +60,6 @@ export type DebugArtifactKind =
 	| "compaction-event"
 	| "lifecycle";
 
-export type ContextManagementMode = "off" | "remote";
-
 /** How Remote V2 obtains the history it sends to the compaction endpoint. */
 export type RemoteV2ContextSource = "pi-context-hook" | "legacy";
 
@@ -79,12 +77,6 @@ export type NativeFallbackConfig = {
 	thinkingLevel: ThinkingLevel;
 };
 
-/**
- * Legacy compatibility setting. Remote Context history is no longer bulk-compacted when
- * selecting a non-window model; local projection and a no-summary boundary own that handoff.
- */
-export type LeaveManagedModePolicy = "warn" | "compact";
-
 export type DebugConfig = {
 	debug: boolean;
 	notifyOnLoad: boolean;
@@ -96,13 +88,6 @@ export type DebugConfig = {
 
 export type CompactionConfig = {
 	enabled: boolean;
-	/**
-	 * Legacy compatibility setting. Non-window consumers never receive retired Remote Context
-	 * history, regardless of this value; retained config files continue to parse it.
-	 */
-	leaveManagedMode: LeaveManagedModePolicy;
-	/** Optional Codex Remote Context management. Disabled by default for compatibility. */
-	contextManagement: ContextManagementMode;
 	/**
 	 * Allow a Responses session whose latest compaction was not created by this extension
 	 * to restart native compaction from Pi's current serialized session context.
@@ -125,16 +110,10 @@ export type CompactionConfig = {
 	 */
 	responsesApis: string[];
 	/**
-	 * Exact "provider/model" keys allowed to use Codex Remote Context on the
-	 * `openai-responses` gateway wire. The native `openai-codex` route ignores
-	 * this list; gateway coverage is opt-in per model.
+	 * Legacy alias for exact "provider/model" Codex gateway transport opt-ins.
+	 * Shared by compaction and image generation; not a window capability.
 	 */
 	gatewayContextModels: string[];
-	/**
-	 * Percentage of the context window that, when remaining tokens drop below it,
-	 * triggers a checkpoint/new_context reminder (0-100; 0 disables reminders).
-	 */
-	contextReminderThresholdPercent: number;
 	notifyOnLoad: boolean;
 	debug: boolean;
 	logProviderPayloads: boolean;
@@ -526,7 +505,6 @@ export const DEFAULT_NATIVE_FALLBACK_CONFIG: NativeFallbackConfig = {
 
 export const DEFAULT_COMPACTION_CONFIG: CompactionConfig = {
 	enabled: true,
-	contextManagement: "off",
 	allowCompactionContinuityBreak: false,
 	remoteCompactModel: undefined,
 	remoteV2ContextSource: "legacy",
@@ -534,8 +512,6 @@ export const DEFAULT_COMPACTION_CONFIG: CompactionConfig = {
 	nativeFallback: { ...DEFAULT_NATIVE_FALLBACK_CONFIG },
 	responsesApis: [...RESPONSES_COMPACT_CAPABLE_APIS],
 	gatewayContextModels: [],
-	leaveManagedMode: "warn",
-	contextReminderThresholdPercent: 5,
 	notifyOnLoad: false,
 	debug: false,
 	logProviderPayloads: false,

package/src/context-management/codex-provider.ts

@@ -1,270 +0,0 @@
-import type { Api, Model, ProviderHeaders } from "@earendil-works/pi-ai";
-import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { mergeProviderHeaders } from "../provider-headers";
-import {
-	CODEX_AFFINITY_SCOPE,
-	CODEX_CLIENT_VERSION,
-	CODEX_GATEWAY_ORIGINATOR,
-	buildCodexCliUserAgent,
-	filterCodexGatewayHeaders,
-} from "../responses-headers";
-export { CODEX_AFFINITY_SCOPE } from "../responses-headers";
-import { normalizeBaseUrl, resolveEffectiveModel, VIRTUAL_MODEL_API } from "../runtime";
-import { isExactModelAllowed } from "../model-scope";
-import {
-	isNonEmptyString,
-	type CodexContextProvider,
-	type CodexContextProviderResolution,
-} from "./types";
-
-const CODEX_PROVIDER = "openai-codex";
-const CODEX_API = "openai-codex-responses";
-const GATEWAY_API = "openai-responses";
-const CODEX_TOOL_ORIGINATOR = CODEX_GATEWAY_ORIGINATOR;
-const CODEX_TOOL_VERSION = "0.0.0";
-const CODEX_SESSION_ID_MAX_LENGTH = 64;
-
-export const CODEX_CONTEXT_PROVIDER_ERROR =
-	"Remote Context management requires a configured Codex-compatible backend";
-
-export function isNativeCodexModel(
-	model: ExtensionContext["model"] | undefined,
-): boolean {
-	return model?.provider === CODEX_PROVIDER && model.api === CODEX_API;
-}
-
-export function isCodexGatewayModel(
-	model: ExtensionContext["model"] | undefined,
-	gatewayModels: readonly string[] = [],
-): boolean {
-	// Gateway coverage is an operator allowlist of exact "provider/model" keys
-	// (compaction.gatewayContextModels). The backend relay must actually pass
-	// hosted window markers through; models outside the list stay on remote
-	// compaction v2.
-	if (!model || model.api !== GATEWAY_API) return false;
-	return isExactModelAllowed(model, gatewayModels);
-}
-
-export function normalizeCodexBackendBaseUrl(baseUrl: string | undefined | null): string | undefined {
-	const normalized = normalizeBaseUrl(baseUrl);
-	if (!normalized) return undefined;
-	try {
-		const url = new URL(normalized);
-		const pathname = url.pathname.replace(/\/+$/, "");
-		if (pathname.endsWith("/codex/responses")) {
-			url.pathname = pathname.slice(0, -"/responses".length);
-			return url.toString().replace(/\/$/, "");
-		}
-		if (pathname.endsWith("/codex")) return normalized;
-		if (pathname.endsWith("/backend-api") || pathname.endsWith("/api")) {
-			return `${normalized}/codex`;
-		}
-		if (pathname === "") return `${normalized}/api/codex`;
-		if (pathname === "/") return `${normalized}/api/codex`;
-		return undefined;
-	} catch {
-		return undefined;
-	}
-}
-
-function headerValue(headers: ProviderHeaders | undefined, name: string): string | undefined {
-	const wanted = name.toLowerCase();
-	for (const [key, value] of Object.entries(headers ?? {})) {
-		if (key.toLowerCase() === wanted && typeof value === "string" && value.trim()) {
-			return value.trim();
-		}
-	}
-	return undefined;
-}
-
-function bearerToken(value: string | undefined): string | undefined {
-	if (!value) return undefined;
-	const match = value.trim().match(/^Bearer\s+(.+)$/i);
-	return (match?.[1] ?? value).trim() || undefined;
-}
-
-function decodeJwtPayload(token: string): Record<string, unknown> | undefined {
-	const parts = token.split(".");
-	if (parts.length !== 3) return undefined;
-	try {
-		const value: unknown = JSON.parse(Buffer.from(parts[1]!, "base64url").toString("utf8"));
-		return value && typeof value === "object" && !Array.isArray(value)
-			? value as Record<string, unknown>
-			: undefined;
-	} catch {
-		return undefined;
-	}
-}
-
-function accountIdFromToken(token: string): string | undefined {
-	const payload = decodeJwtPayload(token);
-	const direct = payload?.chatgpt_account_id;
-	if (isNonEmptyString(direct)) return direct.trim();
-	const auth = payload?.["https://api.openai.com/auth"];
-	if (!auth || typeof auth !== "object" || Array.isArray(auth)) return undefined;
-	const nested = (auth as Record<string, unknown>).chatgpt_account_id;
-	return isNonEmptyString(nested) ? nested.trim() : undefined;
-}
-
-function userAgent(version: string): string {
-	return buildCodexCliUserAgent(version);
-}
-
-function clampSessionId(value: string | undefined): string | undefined {
-	if (!value) return undefined;
-	const chars = Array.from(value.trim());
-	if (chars.length === 0) return undefined;
-	return chars.length <= CODEX_SESSION_ID_MAX_LENGTH
-		? chars.join("")
-		: chars.slice(0, CODEX_SESSION_ID_MAX_LENGTH).join("");
-}
-
-function resolveContextSessionId(ctx: ExtensionContext): string | undefined {
-	try {
-		return clampSessionId(ctx.sessionManager.getSessionId());
-	} catch {
-		return undefined;
-	}
-}
-
-export type CodexContextProviderHeaderOptions = {
-	sessionId?: string;
-	clientRequestId?: string;
-};
-
-export function codexContextProviderHeaders(
-	provider: CodexContextProvider,
-	options: CodexContextProviderHeaderOptions = {},
-): Headers {
-	const headers = new Headers();
-	for (const [name, value] of Object.entries(provider.headers)) {
-		if (typeof value === "string") headers.set(name, value);
-	}
-
-	if (provider.kind === "native-codex") {
-		headers.set("Authorization", `Bearer ${provider.token}`);
-		headers.set("ChatGPT-Account-ID", provider.accountId);
-		headers.set("originator", CODEX_TOOL_ORIGINATOR);
-		headers.set("User-Agent", userAgent(CODEX_TOOL_VERSION));
-	} else {
-		headers.set("Authorization", `Bearer ${provider.apiKey}`);
-		headers.delete("ChatGPT-Account-ID");
-		headers.delete("Cookie");
-		headers.set("originator", CODEX_GATEWAY_ORIGINATOR);
-		headers.set("User-Agent", userAgent(CODEX_CLIENT_VERSION));
-		// Let the gateway own its version policy; preserve an explicitly configured
-		// version already copied from provider.headers above.
-		headers.set("X-Codex-Affinity-Scope", CODEX_AFFINITY_SCOPE);
-		headers.set("X-Codex-Model", provider.model);
-	}
-
-	const sessionId = clampSessionId(options.sessionId);
-	if (sessionId) {
-		headers.set("Session-Id", sessionId);
-		headers.set("X-Client-Request-Id", clampSessionId(options.clientRequestId) ?? sessionId);
-	}
-	headers.set("content-type", "application/json");
-	return headers;
-}
-
-export async function resolveCodexContextProvider(
-	ctx: ExtensionContext,
-	modelOverride: ExtensionContext["model"] = ctx.model,
-	gatewayModels: readonly string[] = [],
-): Promise<CodexContextProviderResolution> {
-	const selectedModel = modelOverride;
-	const selectedDescriptor = {
-		provider: selectedModel?.provider,
-		api: selectedModel?.api,
-		model: selectedModel?.id,
-		baseUrl: normalizeBaseUrl(selectedModel?.baseUrl),
-	};
-	const effective = await resolveEffectiveModel(ctx, selectedModel);
-	if (!effective.ok) return { ok: false, reason: "unsupported-model", ...selectedDescriptor };
-	const model = effective.model;
-	const descriptor = {
-		provider: model.provider,
-		api: model.api,
-		model: model.id,
-		baseUrl: normalizeBaseUrl(model.baseUrl),
-	};
-
-	const isNative = isNativeCodexModel(model);
-	const isLogicalVirtualGateway = selectedModel?.api === VIRTUAL_MODEL_API && isExactModelAllowed(selectedModel, gatewayModels);
-	const isGateway = isCodexGatewayModel(model, gatewayModels) ||
-		(isLogicalVirtualGateway && model.api === GATEWAY_API);
-	if (!isNative && !isGateway) {
-		return { ok: false, reason: "unsupported-model", ...descriptor };
-	}
-	if (!isNative && model.api !== GATEWAY_API) {
-		return { ok: false, reason: "unsupported-api", ...descriptor };
-	}
-	if (isNative && model.api !== CODEX_API) {
-		return { ok: false, reason: "unsupported-api", ...descriptor };
-	}
-
-	let auth: Awaited<ReturnType<typeof ctx.modelRegistry.getApiKeyAndHeaders>>;
-	try {
-		auth = await ctx.modelRegistry.getApiKeyAndHeaders(model as Model<Api>);
-	} catch {
-		return { ok: false, reason: "auth-resolution-failed", ...descriptor };
-	}
-	if (!auth.ok) return { ok: false, reason: "auth-resolution-failed", ...descriptor };
-
-	const rawBaseUrl = normalizeBaseUrl(auth.baseUrl) ?? normalizeBaseUrl(model.baseUrl);
-	if (!rawBaseUrl) return { ok: false, reason: "missing-base-url", ...descriptor };
-
-	if (isGateway) {
-		if (!resolveContextSessionId(ctx)) {
-			return { ok: false, reason: "missing-session-id", ...descriptor, baseUrl: rawBaseUrl };
-		}
-		const apiKey = bearerToken(auth.apiKey) ?? bearerToken(headerValue(auth.headers, "authorization"));
-		if (!apiKey) return { ok: false, reason: "missing-api-key", ...descriptor, baseUrl: rawBaseUrl };
-		return {
-			ok: true,
-			provider: {
-				kind: "codex-gateway",
-				route: "codex-gateway",
-				provider: model.provider,
-				api: GATEWAY_API,
-				model: model.id,
-				baseUrl: rawBaseUrl,
-				apiKey,
-				headers: filterCodexGatewayHeaders(mergeProviderHeaders(model.headers, auth.headers)),
-			},
-		};
-	}
-
-	const token = bearerToken(auth.apiKey) ?? bearerToken(headerValue(auth.headers, "authorization"));
-	if (!token) return { ok: false, reason: "missing-token", ...descriptor };
-	const accountId = headerValue(auth.headers, "chatgpt-account-id") ?? accountIdFromToken(token);
-	if (!accountId) return { ok: false, reason: "missing-account-id", ...descriptor };
-	const baseUrl = normalizeCodexBackendBaseUrl(rawBaseUrl);
-	if (!baseUrl) return { ok: false, reason: "unsupported-backend", ...descriptor };
-
-	const headers = mergeProviderHeaders(model.headers, auth.headers);
-	return {
-		ok: true,
-		provider: {
-			kind: "native-codex",
-			route: "openai-codex",
-			provider: CODEX_PROVIDER,
-			api: CODEX_API,
-			model: model.id,
-			baseUrl,
-			token,
-			accountId,
-			headers,
-		},
-	};
-}
-
-export const _codexProviderTest = {
-	accountIdFromToken,
-	bearerToken,
-	clampSessionId,
-	decodeJwtPayload,
-	headerValue,
-	isCodexGatewayModel,
-	userAgent,
-};