@kodelyth/codex 2026.5.40 → 2026.6.1

package/dist/provider-catalog.js

@@ -0,0 +1,84 @@
+//#region extensions/codex/provider-catalog.ts
+const CODEX_PROVIDER_ID = "codex";
+const CODEX_BASE_URL = "https://chatgpt.com/backend-api";
+const CODEX_APP_SERVER_AUTH_MARKER = "codex-app-server";
+const DEFAULT_CONTEXT_WINDOW = 272e3;
+const DEFAULT_MAX_TOKENS = 128e3;
+const FALLBACK_CODEX_MODELS = [
+	{
+		id: "gpt-5.5",
+		model: "gpt-5.5",
+		displayName: "gpt-5.5",
+		description: "Latest frontier agentic coding model.",
+		isDefault: true,
+		inputModalities: ["text", "image"],
+		supportedReasoningEfforts: [
+			"low",
+			"medium",
+			"high",
+			"xhigh"
+		]
+	},
+	{
+		id: "gpt-5.4-mini",
+		model: "gpt-5.4-mini",
+		displayName: "GPT-5.4-Mini",
+		description: "Smaller frontier agentic coding model.",
+		inputModalities: ["text", "image"],
+		supportedReasoningEfforts: [
+			"low",
+			"medium",
+			"high",
+			"xhigh"
+		]
+	},
+	{
+		id: "gpt-5.2",
+		model: "gpt-5.2",
+		displayName: "gpt-5.2",
+		inputModalities: ["text", "image"],
+		supportedReasoningEfforts: [
+			"low",
+			"medium",
+			"high",
+			"xhigh"
+		]
+	}
+];
+function buildCodexModelDefinition(model) {
+	const id = model.id.trim() || model.model.trim();
+	return {
+		id,
+		name: model.displayName?.trim() || id,
+		api: "openai-codex-responses",
+		reasoning: model.supportedReasoningEfforts.length > 0 || shouldDefaultToReasoningModel(id),
+		input: model.inputModalities.includes("image") ? ["text", "image"] : ["text"],
+		cost: {
+			input: 0,
+			output: 0,
+			cacheRead: 0,
+			cacheWrite: 0
+		},
+		contextWindow: DEFAULT_CONTEXT_WINDOW,
+		maxTokens: DEFAULT_MAX_TOKENS,
+		compat: {
+			supportsReasoningEffort: model.supportedReasoningEfforts.length > 0,
+			supportsUsageInStreaming: true
+		}
+	};
+}
+function buildCodexProviderConfig(models) {
+	return {
+		baseUrl: CODEX_BASE_URL,
+		apiKey: CODEX_APP_SERVER_AUTH_MARKER,
+		auth: "token",
+		api: "openai-codex-responses",
+		models: models.map(buildCodexModelDefinition)
+	};
+}
+function shouldDefaultToReasoningModel(modelId) {
+	const lower = modelId.toLowerCase();
+	return lower.startsWith("gpt-5") || lower.startsWith("o1") || lower.startsWith("o3") || lower.startsWith("o4");
+}
+//#endregion
+export { CODEX_APP_SERVER_AUTH_MARKER, CODEX_BASE_URL, CODEX_PROVIDER_ID, FALLBACK_CODEX_MODELS, buildCodexModelDefinition, buildCodexProviderConfig };

package/dist/provider-discovery.js

@@ -0,0 +1,33 @@
+import { CODEX_APP_SERVER_AUTH_MARKER, CODEX_PROVIDER_ID, FALLBACK_CODEX_MODELS, buildCodexProviderConfig } from "./provider-catalog.js";
+//#region extensions/codex/provider-discovery.ts
+function resolveCodexPluginConfig(ctx) {
+	return (ctx.config.plugins?.entries)?.codex?.config;
+}
+async function runCodexCatalog(ctx) {
+	const { buildCodexProviderCatalog } = await import("./provider.js");
+	return await buildCodexProviderCatalog({
+		env: ctx.env,
+		pluginConfig: resolveCodexPluginConfig(ctx)
+	});
+}
+const codexProviderDiscovery = {
+	id: CODEX_PROVIDER_ID,
+	label: "Codex",
+	docsPath: "/providers/models",
+	auth: [],
+	catalog: {
+		order: "late",
+		run: runCodexCatalog
+	},
+	staticCatalog: {
+		order: "late",
+		run: async () => ({ provider: buildCodexProviderConfig(FALLBACK_CODEX_MODELS) })
+	},
+	resolveSyntheticAuth: () => ({
+		apiKey: CODEX_APP_SERVER_AUTH_MARKER,
+		source: "codex-app-server",
+		mode: "token"
+	})
+};
+//#endregion
+export { codexProviderDiscovery, codexProviderDiscovery as default };

package/dist/provider.js

@@ -0,0 +1,150 @@
+import { CODEX_APP_SERVER_AUTH_MARKER, CODEX_BASE_URL, CODEX_PROVIDER_ID, FALLBACK_CODEX_MODELS, buildCodexModelDefinition, buildCodexProviderConfig } from "./provider-catalog.js";
+import { c as resolveCodexAppServerRuntimeOptions, s as readCodexPluginConfig } from "./config-CezENx_E.js";
+import { resolveCodexSystemPromptContribution } from "./prompt-overlay.js";
+import { resolvePluginConfigObject } from "klaw/plugin-sdk/plugin-config-runtime";
+import { createSubsystemLogger } from "klaw/plugin-sdk/core";
+import { normalizeModelCompat } from "klaw/plugin-sdk/provider-model-shared";
+//#region extensions/codex/provider.ts
+const DEFAULT_DISCOVERY_TIMEOUT_MS = 2500;
+const LIVE_DISCOVERY_ENV = "KLAW_CODEX_DISCOVERY_LIVE";
+const MODEL_DISCOVERY_PAGE_LIMIT = 100;
+const CODEX_APP_SERVER_SETUP_METHOD_ID = "app-server";
+const CODEX_DEFAULT_MODEL_REF = `${CODEX_PROVIDER_ID}/${FALLBACK_CODEX_MODELS[0].id}`;
+const codexCatalogLog = createSubsystemLogger("codex/catalog");
+function buildCodexProvider(options = {}) {
+	return {
+		id: CODEX_PROVIDER_ID,
+		label: "Codex",
+		docsPath: "/providers/models",
+		auth: [{
+			id: CODEX_APP_SERVER_SETUP_METHOD_ID,
+			label: "Codex app-server",
+			hint: "Use the Codex app-server runtime and managed model catalog.",
+			kind: "custom",
+			wizard: {
+				choiceId: CODEX_PROVIDER_ID,
+				choiceLabel: "Codex app-server",
+				choiceHint: "Use the Codex app-server runtime and managed model catalog.",
+				assistantPriority: -40,
+				groupId: CODEX_PROVIDER_ID,
+				groupLabel: "Codex",
+				groupHint: "Codex app-server model provider",
+				onboardingScopes: ["text-inference"]
+			},
+			run: async () => ({
+				profiles: [],
+				defaultModel: CODEX_DEFAULT_MODEL_REF
+			})
+		}],
+		catalog: {
+			order: "late",
+			run: async (ctx) => {
+				const pluginConfig = resolvePluginConfigObject(ctx.config, "codex") ?? (ctx.config ? void 0 : options.pluginConfig);
+				return await buildCodexProviderCatalog({
+					env: ctx.env,
+					pluginConfig,
+					listModels: options.listModels
+				});
+			}
+		},
+		staticCatalog: {
+			order: "late",
+			run: async () => ({ provider: buildCodexProviderConfig(FALLBACK_CODEX_MODELS) })
+		},
+		resolveDynamicModel: (ctx) => resolveCodexDynamicModel(ctx.modelId),
+		resolveSyntheticAuth: () => ({
+			apiKey: CODEX_APP_SERVER_AUTH_MARKER,
+			source: "codex-app-server",
+			mode: "token"
+		}),
+		resolveThinkingProfile: ({ modelId }) => ({ levels: [
+			{ id: "off" },
+			{ id: "minimal" },
+			{ id: "low" },
+			{ id: "medium" },
+			{ id: "high" },
+			...isKnownXHighCodexModel(modelId) ? [{ id: "xhigh" }] : []
+		] }),
+		resolveSystemPromptContribution: ({ config, modelId }) => resolveCodexSystemPromptContribution({
+			config,
+			modelId
+		}),
+		isModernModelRef: ({ modelId }) => isModernCodexModel(modelId)
+	};
+}
+async function buildCodexProviderCatalog(options = {}) {
+	const config = readCodexPluginConfig(options.pluginConfig);
+	const appServer = resolveCodexAppServerRuntimeOptions({ pluginConfig: options.pluginConfig });
+	const timeoutMs = normalizeTimeoutMs(config.discovery?.timeoutMs);
+	let discovered = [];
+	if (config.discovery?.enabled !== false && !shouldSkipLiveDiscovery(options.env)) discovered = await listModelsBestEffort({
+		listModels: options.listModels ?? listCodexAppServerModelsLazy,
+		timeoutMs,
+		startOptions: appServer.start,
+		onDiscoveryFailure: options.onDiscoveryFailure
+	});
+	return { provider: buildCodexProviderConfig(discovered.length > 0 ? discovered : FALLBACK_CODEX_MODELS) };
+}
+function resolveCodexDynamicModel(modelId) {
+	const id = modelId.trim();
+	if (!id) return;
+	const fallbackModel = FALLBACK_CODEX_MODELS.find((model) => model.id === id);
+	return normalizeModelCompat({
+		...buildCodexModelDefinition({
+			id,
+			model: id,
+			inputModalities: fallbackModel?.inputModalities ?? ["text"],
+			supportedReasoningEfforts: fallbackModel?.supportedReasoningEfforts ?? (shouldDefaultToReasoningModel(id) ? ["medium"] : [])
+		}),
+		provider: CODEX_PROVIDER_ID,
+		baseUrl: CODEX_BASE_URL
+	});
+}
+async function listModelsBestEffort(params) {
+	try {
+		const models = [];
+		let cursor;
+		do {
+			const result = await params.listModels({
+				timeoutMs: params.timeoutMs,
+				limit: MODEL_DISCOVERY_PAGE_LIMIT,
+				cursor,
+				startOptions: params.startOptions,
+				sharedClient: false
+			});
+			models.push(...result.models.filter((model) => !model.hidden));
+			cursor = result.nextCursor;
+		} while (cursor);
+		return models;
+	} catch (error) {
+		params.onDiscoveryFailure?.(error);
+		codexCatalogLog.debug("codex model discovery failed; using fallback catalog", { error: error instanceof Error ? error.message : String(error) });
+		return [];
+	}
+}
+async function listCodexAppServerModelsLazy(options) {
+	const { listCodexAppServerModels } = await import("./models-B9DhrIwD.js").then((n) => n.r);
+	return listCodexAppServerModels(options);
+}
+function normalizeTimeoutMs(value) {
+	return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : DEFAULT_DISCOVERY_TIMEOUT_MS;
+}
+function shouldSkipLiveDiscovery(env = process.env) {
+	const override = env[LIVE_DISCOVERY_ENV]?.trim().toLowerCase();
+	if (override === "0" || override === "false") return true;
+	return Boolean(env.VITEST) && override !== "1";
+}
+function shouldDefaultToReasoningModel(modelId) {
+	const lower = modelId.toLowerCase();
+	return lower.startsWith("gpt-5") || lower.startsWith("o1") || lower.startsWith("o3") || lower.startsWith("o4");
+}
+function isKnownXHighCodexModel(modelId) {
+	const lower = modelId.trim().toLowerCase();
+	return lower.startsWith("gpt-5") || lower.startsWith("o3") || lower.startsWith("o4") || lower.includes("codex");
+}
+function isModernCodexModel(modelId) {
+	const lower = modelId.trim().toLowerCase();
+	return lower === "gpt-5.5" || lower === "gpt-5.4" || lower === "gpt-5.4-mini" || lower === "gpt-5.2";
+}
+//#endregion
+export { buildCodexProvider, buildCodexProviderCatalog, isModernCodexModel };

package/dist/rate-limit-cache-CHuacE27.js

@@ -0,0 +1,24 @@
+//#region extensions/codex/src/app-server/rate-limit-cache.ts
+const DEFAULT_CODEX_RATE_LIMIT_CACHE_MAX_AGE_MS = 10 * 6e4;
+const CODEX_RATE_LIMIT_CACHE_STATE = Symbol.for("klaw.codexRateLimitCacheState");
+function getCodexRateLimitCacheState() {
+	const globalState = globalThis;
+	globalState[CODEX_RATE_LIMIT_CACHE_STATE] ??= {};
+	return globalState[CODEX_RATE_LIMIT_CACHE_STATE];
+}
+function rememberCodexRateLimits(value, nowMs = Date.now()) {
+	if (value === void 0) return;
+	const state = getCodexRateLimitCacheState();
+	state.value = value;
+	state.updatedAtMs = nowMs;
+}
+function readRecentCodexRateLimits(options) {
+	const state = getCodexRateLimitCacheState();
+	if (state.value === void 0 || state.updatedAtMs === void 0) return;
+	const nowMs = options?.nowMs ?? Date.now();
+	const maxAgeMs = options?.maxAgeMs ?? DEFAULT_CODEX_RATE_LIMIT_CACHE_MAX_AGE_MS;
+	if (maxAgeMs >= 0 && nowMs - state.updatedAtMs > maxAgeMs) return;
+	return state.value;
+}
+//#endregion
+export { rememberCodexRateLimits as n, readRecentCodexRateLimits as t };

package/dist/request-CTQKUxaa.js

@@ -0,0 +1,89 @@
+import { n as CodexAppServerRpcError } from "./client-ChMX13_o.js";
+import { f as resolveCodexAppServerHomeDir, i as getSharedCodexAppServerClient, o as withTimeout, r as createIsolatedCodexAppServerClient } from "./shared-client-Cnyr9dyT.js";
+import { i as buildCodexAppInventoryCacheKey } from "./plugin-activation-BlMuJeXz.js";
+import { createHash } from "node:crypto";
+//#region extensions/codex/src/app-server/capabilities.ts
+const CODEX_CONTROL_METHODS = {
+	account: "account/read",
+	compact: "thread/compact/start",
+	feedback: "feedback/upload",
+	listMcpServers: "mcpServerStatus/list",
+	listSkills: "skills/list",
+	listThreads: "thread/list",
+	rateLimits: "account/rateLimits/read",
+	resumeThread: "thread/resume",
+	review: "review/start"
+};
+function describeControlFailure(error) {
+	if (isUnsupportedControlError(error)) return "unsupported by this Codex app-server";
+	return error instanceof Error ? error.message : String(error);
+}
+function isUnsupportedControlError(error) {
+	return error instanceof CodexAppServerRpcError && error.code === -32601;
+}
+//#endregion
+//#region extensions/codex/src/app-server/plugin-app-cache-key.ts
+function buildCodexPluginAppCacheKey(params) {
+	return buildCodexAppInventoryCacheKey({
+		codexHome: resolveCodexPluginAppCacheCodexHome(params.appServer, params.agentDir),
+		endpoint: resolveCodexPluginAppCacheEndpoint(params.appServer),
+		authProfileId: params.authProfileId,
+		accountId: params.accountId,
+		envApiKeyFingerprint: params.envApiKeyFingerprint,
+		appServerVersion: params.appServerVersion
+	});
+}
+function resolveCodexPluginAppCacheEndpoint(appServer) {
+	return JSON.stringify({
+		transport: appServer.start.transport,
+		command: appServer.start.command,
+		args: appServer.start.args,
+		url: appServer.start.url ?? null,
+		credentialFingerprint: fingerprintCodexPluginAppCacheCredentials(appServer.start)
+	});
+}
+function resolveCodexPluginAppCacheCodexHome(appServer, agentDir) {
+	const configuredCodexHome = appServer.start.env?.CODEX_HOME?.trim();
+	if (configuredCodexHome) return configuredCodexHome;
+	return appServer.start.transport === "stdio" && agentDir ? resolveCodexAppServerHomeDir(agentDir) : void 0;
+}
+function fingerprintCodexPluginAppCacheCredentials(startOptions) {
+	const authToken = startOptions.authToken ?? "";
+	const headers = Object.entries(startOptions.headers).map(([key, value]) => [key.toLowerCase(), value]).toSorted(([left], [right]) => left.localeCompare(right));
+	if (!authToken && headers.length === 0) return null;
+	const hash = createHash("sha256");
+	hash.update("klaw:codex:plugin-app-cache-credentials:v1");
+	hash.update("\0");
+	hash.update(authToken);
+	for (const [key, value] of headers) {
+		hash.update("\0");
+		hash.update(key);
+		hash.update("\0");
+		hash.update(value);
+	}
+	return `sha256:${hash.digest("hex")}`;
+}
+//#endregion
+//#region extensions/codex/src/app-server/request.ts
+async function requestCodexAppServerJson(params) {
+	const timeoutMs = params.timeoutMs ?? 6e4;
+	return await withTimeout((async () => {
+		const client = await (params.isolated ? createIsolatedCodexAppServerClient : getSharedCodexAppServerClient)({
+			startOptions: params.startOptions,
+			timeoutMs,
+			authProfileId: params.authProfileId,
+			agentDir: params.agentDir,
+			config: params.config
+		});
+		try {
+			return await client.request(params.method, params.requestParams, { timeoutMs });
+		} finally {
+			if (params.isolated) await client.closeAndWait({
+				exitTimeoutMs: 2e3,
+				forceKillDelayMs: 250
+			});
+		}
+	})(), timeoutMs, `codex app-server ${params.method} timed out`);
+}
+//#endregion
+export { describeControlFailure as i, buildCodexPluginAppCacheKey as n, CODEX_CONTROL_METHODS as r, requestCodexAppServerJson as t };

package/dist/rolldown-runtime-DUslC3ob.js

@@ -0,0 +1,14 @@
+import "node:module";
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+export { __exportAll as t };