@shuind/dsh-codex-harness 0.1.10 → 0.1.12

package/lib/index.js

@@ -1,7 +1,12 @@
 import z from "@deepseek-ai/schemastery";
+import { installSettingsSection, settingsNamespace } from "@deepseek-ai/dsh-settings";
 import { defineTool } from "@deepseek-ai/dsh-tools";
 import { randomBytes } from "node:crypto";
 import { resolve } from "node:path";
+import { credentialRef } from "@deepseek-ai/dsh-credentials";
+import { AsyncLocalStorage } from "node:async_hooks";
+//#region lib/types/context.js
+const CODEX_CONTEXT_MAX = 1e6;
 String.raw`start: begin_patch hunk+ end_patch
 begin_patch: "*** Begin Patch" LF
 end_patch: "*** End Patch" LF?
@@ -399,6 +404,309 @@ async function runWriteStdin(ctx, args, exec, config) {
 	return output;
 }
 //#endregion
+//#region lib/types/remote.js
+const SETTINGS_NAMESPACE = "llm-pi-ai";
+const REMOTE_COMPACTION_OPEN = "<codex-remote-compaction>";
+const REMOTE_COMPACTION_CLOSE = "</codex-remote-compaction>";
+const HOSTED_REQUESTS = new AsyncLocalStorage();
+let hostedPatchUsers = 0;
+let hostedPatchRestore;
+function isGptModel$1(model) {
+	return typeof model === "string" && /(?:^|\/)(?:gpt|chatgpt)(?:[-_.]|\d|$)/i.test(model);
+}
+function settingsOf(ctx) {
+	return ctx.get("settings")?.get?.(SETTINGS_NAMESPACE);
+}
+function profileOf(ctx, provider) {
+	return settingsOf(ctx)?.providers?.[provider];
+}
+function supportsResponses(profile, provider) {
+	return profile?.api === "openai-responses" || profile?.api === "openai-codex-responses" || profile?.api === void 0 && provider === "openai";
+}
+function responsesEndpoint(baseURL, suffix) {
+	return `${baseURL.replace(/\/+$/, "")}/${suffix}`;
+}
+function hasHeader(headers, name) {
+	return Object.keys(headers ?? {}).some((key) => key.toLowerCase() === name.toLowerCase());
+}
+async function apiHeaders(ctx, profile) {
+	const headers = {
+		...profile.headers,
+		"content-type": "application/json"
+	};
+	if (profile.apiKeyEnv !== void 0 && !hasHeader(headers, "authorization")) {
+		const resolved = await ctx.get("credentials")?.resolve(credentialRef(profile.apiKeyEnv));
+		if (resolved?.value === void 0) return void 0;
+		headers.authorization = `Bearer ${resolved.value}`;
+	}
+	return headers;
+}
+function isResponsesRequest(url) {
+	try {
+		return new URL(url).pathname.replace(/\/+$/, "").endsWith("/responses");
+	} catch {
+		return url.replace(/\/+$/, "").endsWith("/responses");
+	}
+}
+function isWebSearchTool(tool) {
+	if (typeof tool !== "object" || tool === null) return false;
+	const value = tool;
+	if (value.name === "web_search") return true;
+	const fn = value.function;
+	return typeof fn === "object" && fn !== null && fn.name === "web_search";
+}
+function hasWebSearchTool(body) {
+	return Array.isArray(body.tools) && body.tools.some(isWebSearchTool);
+}
+/** Convert a generic DSH Responses tool list to the hosted Codex variant. */
+function addHostedWebSearch(body) {
+	const tools = Array.isArray(body.tools) ? body.tools.filter((tool) => !isWebSearchTool(tool)) : [];
+	tools.push({
+		type: "web_search",
+		external_web_access: true
+	});
+	return {
+		...replaceRemoteCompactions(body),
+		tools
+	};
+}
+/** Replace the text placeholder written by dsh-compaction-basic with the native item. */
+function replaceRemoteCompactions(body) {
+	if (!Array.isArray(body.input)) return body;
+	const input = body.input.map((item) => {
+		if (typeof item !== "object" || item === null) return item;
+		const value = item;
+		const marker = (Array.isArray(value.content) ? value.content : []).find((part) => typeof part === "object" && part !== null && typeof part.text === "string" && String(part.text).includes(REMOTE_COMPACTION_OPEN));
+		if (marker === void 0) return item;
+		const text = String(marker.text);
+		const start = text.indexOf(REMOTE_COMPACTION_OPEN) + 25;
+		const end = text.indexOf(REMOTE_COMPACTION_CLOSE, start);
+		if (end < start) return item;
+		return {
+			type: "compaction",
+			encrypted_content: text.slice(start, end)
+		};
+	});
+	return {
+		...body,
+		input
+	};
+}
+function hasRemoteCompaction(body) {
+	if (!Array.isArray(body.input)) return false;
+	return body.input.some((item) => {
+		if (typeof item !== "object" || item === null) return false;
+		const content = item.content;
+		return Array.isArray(content) && content.some((part) => typeof part === "object" && part !== null && typeof part.text === "string" && String(part.text).includes(REMOTE_COMPACTION_OPEN));
+	});
+}
+function canPatchBody(body) {
+	return isGptModel$1(body.model) && (hasWebSearchTool(body) || hasRemoteCompaction(body));
+}
+/**
+* Install a scoped fetch shim for pi-ai's already-built Responses request.
+* The generic DSH adapter remains the owner of auth, streaming, replay, and
+* attachments; this shim changes only the hosted-tool portion of the wire body.
+*/
+function installGlobalHostedWebSearchPatch() {
+	const original = globalThis.fetch;
+	const patched = async (input, init) => {
+		if (!HOSTED_REQUESTS.getStore()) return original(input, init);
+		const request = new Request(input, init);
+		if (!isResponsesRequest(request.url)) return original(input, init);
+		let body;
+		try {
+			body = JSON.parse(await request.clone().text());
+		} catch {
+			return original(input, init);
+		}
+		if (!canPatchBody(body)) return original(input, init);
+		const fallbackRequest = request.clone();
+		const headers = new Headers(request.headers);
+		headers.delete("content-length");
+		const hostedRequest = new Request(request, {
+			body: JSON.stringify(hasWebSearchTool(body) ? addHostedWebSearch(body) : replaceRemoteCompactions(body)),
+			headers
+		});
+		try {
+			const hostedResponse = await original(hostedRequest);
+			if (!hostedResponse.ok) return original(fallbackRequest);
+			return hostedResponse;
+		} catch {
+			return original(fallbackRequest);
+		}
+	};
+	globalThis.fetch = patched;
+	return () => {
+		if (globalThis.fetch === patched) globalThis.fetch = original;
+	};
+}
+/** Enable the transport patch for this Codex plugin scope only. */
+function installHostedWebSearch() {
+	hostedPatchUsers += 1;
+	hostedPatchRestore ??= installGlobalHostedWebSearchPatch();
+	return () => {
+		hostedPatchUsers = Math.max(0, hostedPatchUsers - 1);
+		if (hostedPatchUsers === 0) {
+			hostedPatchRestore?.();
+			hostedPatchRestore = void 0;
+		}
+	};
+}
+/** Iterate an existing DSH stream with the hosted-request context installed. */
+function hostedWebSearchStream(next) {
+	return (async function* () {
+		const iterator = next()[Symbol.asyncIterator]();
+		let completed = false;
+		try {
+			while (true) {
+				const item = await HOSTED_REQUESTS.run(true, () => iterator.next());
+				if (item.done) {
+					completed = true;
+					return;
+				}
+				yield item.value;
+			}
+		} finally {
+			if (!completed) await iterator.return?.();
+		}
+	})();
+}
+function textOf(message) {
+	return message.content.filter((block) => block.type === "text").map((block) => block.text).join("");
+}
+function responsesInput(messages) {
+	const result = [];
+	for (const message of messages) {
+		const text = textOf(message);
+		if (message.role === "assistant") {
+			if (text.length > 0) result.push({
+				type: "message",
+				role: "assistant",
+				content: [{
+					type: "output_text",
+					text
+				}]
+			});
+			for (const block of message.content) if (block.type === "tool-call") result.push({
+				type: "function_call",
+				call_id: block.id,
+				name: block.name,
+				arguments: block.arguments
+			});
+			continue;
+		}
+		const role = message.role === "system" ? "developer" : "user";
+		if (text.length > 0) result.push({
+			type: "message",
+			role,
+			content: [{
+				type: "input_text",
+				text
+			}]
+		});
+		for (const block of message.content) {
+			if (block.type !== "tool-result") continue;
+			result.push({
+				type: "function_call_output",
+				call_id: block.toolCallId,
+				output: block.content.filter((item) => item.type === "text").map((item) => item.text).join("")
+			});
+		}
+	}
+	return result;
+}
+function responsesTools(tools) {
+	if (tools === void 0) return void 0;
+	return tools.filter((tool) => tool.name !== "web_search").map((tool) => ({
+		type: "function",
+		name: tool.name,
+		description: tool.description,
+		parameters: tool.parameters
+	}));
+}
+function compactBody(options) {
+	const tools = responsesTools(options.tools);
+	const compacted = replaceRemoteCompactions({
+		model: options.model,
+		input: responsesInput(options.messages.slice(0, -1)),
+		...options.system === void 0 ? {} : { instructions: options.system },
+		...tools === void 0 ? {} : { tools },
+		...options.maxTokens === void 0 ? {} : { max_output_tokens: options.maxTokens },
+		...options.reasoningEffort === void 0 ? {} : { reasoning: { effort: options.reasoningEffort } }
+	});
+	return options.tools?.some((tool) => tool.name === "web_search") ? addHostedWebSearch(compacted) : compacted;
+}
+function compactText(body) {
+	const output = Array.isArray(body.output) ? body.output : [];
+	const text = [];
+	for (const item of output) {
+		if (typeof item !== "object" || item === null) continue;
+		const value = item;
+		if (typeof value.encrypted_content === "string") text.push(value.encrypted_content);
+	}
+	const encrypted = text.join("\n\n").trim();
+	return encrypted.length === 0 ? "" : `${REMOTE_COMPACTION_OPEN}${encrypted}${REMOTE_COMPACTION_CLOSE}`;
+}
+async function remoteCompact(ctx, options) {
+	const profile = profileOf(ctx, options.provider);
+	if (!supportsResponses(profile, options.provider) || profile?.baseURL === void 0) throw new Error("Codex remote compaction requires an OpenAI Responses provider with baseURL");
+	const headers = await apiHeaders(ctx, profile);
+	if (headers === void 0) throw new Error("Codex remote compaction has no configured API key");
+	const response = await fetch(responsesEndpoint(profile.baseURL, "responses/compact"), {
+		method: "POST",
+		headers,
+		body: JSON.stringify(compactBody(options)),
+		...options.signal === void 0 ? {} : { signal: options.signal }
+	});
+	if (!response.ok) throw new Error(`remote compaction returned HTTP ${response.status}`);
+	const text = compactText(await response.json());
+	if (text.length === 0) throw new Error("remote compaction returned no compaction text");
+	return text;
+}
+/** Remote-first compaction waterfall with the existing DSH path as fallback. */
+function remoteCompactStream(ctx, options, next) {
+	return (async function* () {
+		try {
+			const text = await remoteCompact(ctx, options);
+			yield {
+				type: "block-start",
+				index: 0,
+				blockType: "text"
+			};
+			yield {
+				type: "text-delta",
+				index: 0,
+				text
+			};
+			yield {
+				type: "block-end",
+				index: 0,
+				block: {
+					type: "text",
+					text
+				}
+			};
+			yield {
+				type: "usage",
+				usage: {
+					inputTokens: 0,
+					outputTokens: 0
+				}
+			};
+			yield {
+				type: "finish",
+				reason: { kind: "stop" }
+			};
+		} catch (error) {
+			if (options.signal?.aborted) throw error;
+			ctx.logger.warn("codex: remote compaction failed; using dsh-compaction-basic fallback");
+			ctx.logger.warn(error);
+			yield* hostedWebSearchStream(next);
+		}
+	})();
+}
+//#endregion
 //#region lib/types/index.js
 /** Codex-compatible prompt overlay and core tools for a dsh agent preset. */
 const name = "codex";
@@ -406,15 +714,132 @@ const inject = [
 	"tools",
 	"systemPrompt",
 	"shell",
-	"fs"
+	"fs",
+	"llm",
+	"credentials",
+	"settings"
 ];
 /** Runtime configuration schema for the Codex tool bridge. */
 const Config = z.object({
 	defaultYieldTimeMs: z.number().step(1).min(0).default(1e4),
 	pollYieldTimeMs: z.number().step(1).min(0).default(5e3),
 	writeYieldTimeMs: z.number().step(1).min(0).default(250),
-	maxOutputBytes: z.number().step(1).min(1).default(64e3)
+	maxOutputBytes: z.number().step(1).min(1).default(64e3),
+	hostedWebSearch: z.boolean().default(true),
+	remoteCompact: z.boolean().default(true)
+});
+const LLM_PI_AI_SETTINGS = settingsNamespace("llm-pi-ai");
+/** Live Codex-only request controls shared by the Web controls and agent layer. */
+const CODEX_SETTINGS_NAMESPACE = settingsNamespace("codex");
+const CODEX_SETTINGS_SCHEMA = z.object({
+	fast: z.boolean().default(false),
+	contextWindow: z.number().step(1).min(1).max(CODEX_CONTEXT_MAX)
 });
+const CODEX_SETTINGS_ENTRY = { fast: false };
+const GPT_REASONING_EFFORTS = {
+	low: "low",
+	medium: "medium",
+	high: "high",
+	xhigh: "xhigh",
+	max: "max"
+};
+function codexReasoningEfforts(configured) {
+	if (configured === false) return false;
+	const filtered = configured === void 0 ? {} : Object.fromEntries(Object.entries(configured).filter(([level]) => level !== "off" && level !== "minimal"));
+	return Object.keys(filtered).length === 0 ? GPT_REASONING_EFFORTS : filtered;
+}
+/** GPT model ids are the only models whose relay capabilities Codex fills in. */
+function isGptModel(id) {
+	return /(?:^|\/)(?:gpt|chatgpt)(?:[-_.]|\d|$)/i.test(id);
+}
+/** Add Codex defaults without overwriting explicit user capabilities. */
+function enrichCodexModel(model) {
+	if (!isGptModel(model.id)) return model;
+	const input = model.input === void 0 || model.input.length === 0 ? ["text", "image"] : model.input;
+	const efforts = codexReasoningEfforts(model.reasoningEfforts);
+	if (input === model.input && efforts === model.reasoningEfforts) return model;
+	return {
+		...model,
+		input,
+		reasoningEfforts: efforts
+	};
+}
+/** The settings schema keys modelOverrides by id, so its values must not carry an id field. */
+function enrichCodexOverride(id, model) {
+	if (!isGptModel(id)) return model;
+	const { id: _id, ...withoutId } = enrichCodexModel({
+		...model,
+		id
+	});
+	const inputMissing = model.input === void 0 || model.input.length === 0;
+	const nextEfforts = codexReasoningEfforts(model.reasoningEfforts);
+	const reasoningChanged = JSON.stringify(nextEfforts) !== JSON.stringify(model.reasoningEfforts);
+	if (!inputMissing && !reasoningChanged) return model;
+	return {
+		...withoutId,
+		reasoningEfforts: nextEfforts
+	};
+}
+/** Persist only missing GPT capabilities into the user's existing pi-ai model config. */
+async function enrichConfiguredGptModels(ctx) {
+	const settings = ctx.get("settings");
+	if (settings === void 0) return;
+	const current = settings.get(LLM_PI_AI_SETTINGS);
+	if (current?.providers === void 0) return;
+	const providers = {};
+	let changed = false;
+	for (const [provider, profile] of Object.entries(current.providers)) {
+		const models = profile.models;
+		const overrides = profile.modelOverrides;
+		const nextModels = Array.isArray(models) ? models.map(enrichCodexModel) : void 0;
+		const nextOverrides = overrides === void 0 ? void 0 : Object.fromEntries(Object.entries(overrides).map(([id, model]) => [id, enrichCodexOverride(id, model)]));
+		const modelsChanged = nextModels !== void 0 && nextModels.some((model, index) => model !== models?.[index]);
+		const overridesChanged = nextOverrides !== void 0 && overrides !== void 0 && Object.entries(nextOverrides).some(([id, model]) => model !== overrides[id]);
+		if (modelsChanged || overridesChanged) {
+			changed = true;
+			providers[provider] = {
+				...modelsChanged ? { models: nextModels } : {},
+				...overridesChanged ? { modelOverrides: nextOverrides } : {}
+			};
+		}
+	}
+	if (changed) await settings.update(LLM_PI_AI_SETTINGS, { providers });
+}
+/** Keep newly edited GPT model entries enriched while Codex mode is mounted. */
+function watchConfiguredGptModels(ctx) {
+	let tail = Promise.resolve();
+	const schedule = () => {
+		tail = tail.then(() => enrichConfiguredGptModels(ctx)).catch((error) => {
+			ctx.logger.warn("codex: could not enrich configured GPT model capabilities");
+			ctx.logger.warn(error);
+		});
+	};
+	ctx.on("settings/document-updated", (ns) => {
+		if (ns === LLM_PI_AI_SETTINGS) schedule();
+	});
+	schedule();
+}
+/** Install the optional settings source used by the request waterfall. */
+function installCodexSettings(ctx) {
+	let source = () => CODEX_SETTINGS_ENTRY;
+	installSettingsSection(ctx, CODEX_SETTINGS_NAMESPACE, CODEX_SETTINGS_SCHEMA, CODEX_SETTINGS_ENTRY, {
+		setSource: (current) => {
+			source = current;
+		},
+		onChange: () => {}
+	});
+	return { current: () => source() };
+}
+/** Apply the live Codex controls to one agent request without leaking them to other routes. */
+function applyCodexRequestSettings(request, settings) {
+	const { contextWindow: _inheritedContextWindow, serviceTier: _inheritedServiceTier, ...withoutCodexControls } = request;
+	if (!isGptModel(request.model)) return withoutCodexControls;
+	return {
+		...withoutCodexControls,
+		...settings.contextWindow === void 0 ? {} : { contextWindow: settings.contextWindow },
+		...settings.fast ? { serviceTier: "priority" } : {}
+	};
+}
 const CODEX_BASE_PROMPT = String.raw`You are Codex, based on {{model}}. You are running as a coding agent in dsh Web on a user's computer.
 
 ## General
@@ -821,9 +1246,25 @@ function apply(ctx, config = {}) {
 		defaultYieldTimeMs: config.defaultYieldTimeMs ?? 1e4,
 		pollYieldTimeMs: config.pollYieldTimeMs ?? 5e3,
 		writeYieldTimeMs: config.writeYieldTimeMs ?? 250,
-		maxOutputBytes: config.maxOutputBytes ?? 64e3
+		maxOutputBytes: config.maxOutputBytes ?? 64e3,
+		hostedWebSearch: config.hostedWebSearch ?? true,
+		remoteCompact: config.remoteCompact ?? true
 	};
 	if (ctx.fs.sandboxMode !== void 0 && ctx.get("sandboxPolicy") === void 0) throw new Error("codex: a sandboxing filesystem requires ctx.sandboxPolicy");
+	watchConfiguredGptModels(ctx);
+	const codexSettings = installCodexSettings(ctx);
+	ctx.on("agent/request", async (_payload, next) => {
+		return applyCodexRequestSettings(await next(), codexSettings.current());
+	});
+	if ((resolved.hostedWebSearch || resolved.remoteCompact) && typeof ctx.effect === "function") {
+		const disposeHostedWebSearch = installHostedWebSearch();
+		ctx.effect(() => disposeHostedWebSearch, "codex: Responses transport wrapper");
+	}
+	if (resolved.hostedWebSearch || resolved.remoteCompact) ctx.on("llm/stream", ((options, next) => {
+		if (resolved.remoteCompact && options.purpose === "compaction" && isGptModel(options.model)) return remoteCompactStream(ctx, options, next);
+		if ((resolved.hostedWebSearch || resolved.remoteCompact) && options.purpose === void 0 && isGptModel(options.model)) return hostedWebSearchStream(next);
+		return next();
+	}));
 	ctx.systemPrompt.section({
 		name: "codex:base",
 		order: 10,
@@ -840,4 +1281,4 @@ var types_default = {
 	apply
 };
 //#endregion
-export { Config, apply, types_default as default, inject, name };
+export { CODEX_SETTINGS_NAMESPACE, CODEX_SETTINGS_SCHEMA, Config, apply, applyCodexRequestSettings, types_default as default, enrichCodexModel, inject, name };

package/lib/types/client/index.d.ts

@@ -0,0 +1,40 @@
+/** Browser controls for the Codex request settings mounted by the Host plugin. */
+import type { Context } from '@deepseek-ai/cordis';
+declare const en: {
+    readonly fast: "Fast mode";
+    readonly fastOn: "Fast mode on (priority tier)";
+    readonly fastOff: "Fast mode off";
+    readonly fastStateOn: "On";
+    readonly fastStateOff: "Off";
+    readonly contextSize: "Context size";
+    readonly contextSizeDescription: "Next request capacity in K tokens. The meter above is current.";
+    readonly contextRestore: "Restore model default";
+};
+type CodexKey = keyof typeof en;
+declare module '@deepseek-ai/dsh-client-ui-slots' {
+    interface LocaleNamespaceMap {
+        codex: CodexKey;
+    }
+    interface SlotMap {
+        'conversation.input.model.settings': {
+            kind: 'list';
+            scope: 'session';
+        };
+        'conversation.input.context.settings': {
+            kind: 'list';
+            scope: 'session';
+            owner: {
+                contextWindow: number;
+            };
+        };
+    }
+}
+export declare const inject: string[];
+/** Mount Fast inside the model selector and context size inside the meter panel. */
+export declare function apply(ctx: Context): void;
+declare const _default: {
+    inject: string[];
+    apply: typeof apply;
+};
+export default _default;
+//# sourceMappingURL=index.d.ts.map

package/lib/types/client/index.js

@@ -0,0 +1,112 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { CODEX_CONTEXT_MAX, CODEX_CONTEXT_UNIT, CODEX_PRESET_ID } from "../context.js";
+const NS = 'codex';
+const SETTINGS_NAMESPACE = 'codex';
+const en = {
+    fast: 'Fast mode',
+    fastOn: 'Fast mode on (priority tier)',
+    fastOff: 'Fast mode off',
+    fastStateOn: 'On',
+    fastStateOff: 'Off',
+    contextSize: 'Context size',
+    contextSizeDescription: 'Next request capacity in K tokens. The meter above is current.',
+    contextRestore: 'Restore model default',
+};
+const zh = {
+    fast: 'Fast',
+    fastOn: 'Fast mode on (priority tier)',
+    fastOff: 'Fast mode off',
+    fastStateOn: '开',
+    fastStateOff: '关',
+    contextSize: '上下文大小',
+    contextSizeDescription: '设置下次请求的上下文容量，单位为 K tokens；上方是当前请求。',
+    contextRestore: '恢复模型默认值',
+};
+function FastModeButton({ sessionId, useSessions, useSettings, setSetting, t }) {
+    const agentPreset = useSessions(state => state.byId[sessionId]?.agentPreset);
+    const snapshot = useSettings(state => state);
+    const fast = snapshot.value?.fast ?? false;
+    if (agentPreset !== CODEX_PRESET_ID)
+        return null;
+    return (_jsxs("button", { type: "button", role: "menuitemcheckbox", disabled: snapshot.writable === false, "aria-pressed": fast, "aria-label": fast ? t('fastOn') : t('fastOff'), title: fast ? t('fastOn') : t('fastOff'), onClick: () => { void setSetting('fast', !fast); }, style: {
+            boxSizing: 'border-box',
+            display: 'flex',
+            alignItems: 'center',
+            justifyContent: 'space-between',
+            width: '100%',
+            height: 40,
+            border: 0,
+            borderRadius: 10,
+            padding: '0 10px',
+            color: fast ? 'var(--dsw-static-blue-500)' : 'var(--dsw-alias-label-secondary)',
+            background: fast ? 'var(--dsw-alias-interactive-bg-selected)' : 'transparent',
+            cursor: snapshot.writable === false ? 'default' : 'pointer',
+            font: 'inherit',
+            fontSize: 14,
+            lineHeight: '22px',
+            fontWeight: fast ? 600 : 400,
+            textAlign: 'left',
+        }, children: [_jsx("span", { children: t('fast') }), _jsx("span", { style: { color: 'var(--dsw-alias-label-tertiary)', fontSize: 12 }, children: fast ? t('fastStateOn') : t('fastStateOff') })] }));
+}
+function ContextSizeControl({ contextWindow, useSettings, setSetting, unsetSetting, t }) {
+    const snapshot = useSettings(state => state);
+    const configured = snapshot.value?.contextWindow;
+    const maxK = CODEX_CONTEXT_MAX / CODEX_CONTEXT_UNIT;
+    const valueK = Math.min(maxK, Math.max(1, Math.round((configured ?? contextWindow) / CODEX_CONTEXT_UNIT)));
+    const setValueK = (nextK) => {
+        if (!Number.isFinite(nextK))
+            return;
+        const normalizedK = Math.min(maxK, Math.max(1, Math.trunc(nextK)));
+        const normalized = normalizedK * CODEX_CONTEXT_UNIT;
+        if (normalized === contextWindow)
+            void unsetSetting('contextWindow');
+        else
+            void setSetting('contextWindow', normalized);
+    };
+    return (_jsxs("div", { style: { marginTop: 10, display: 'grid', gap: 5 }, children: [_jsxs("div", { style: { display: 'flex', alignItems: 'baseline', justifyContent: 'space-between', gap: 12 }, children: [_jsx("strong", { style: { color: 'var(--dsw-alias-label-primary)', fontSize: 12 }, children: t('contextSize') }), _jsxs("span", { style: { color: 'var(--dsw-alias-label-secondary)', fontSize: 11 }, children: [valueK, "K"] })] }), _jsx("input", { type: "range", min: 1, max: maxK, step: 1, value: valueK, disabled: snapshot.writable === false, "aria-label": t('contextSize'), onChange: event => { setValueK(Number(event.target.value)); } }), _jsxs("div", { style: { display: 'flex', alignItems: 'center', gap: 7 }, children: [_jsx("input", { type: "number", min: 1, max: maxK, step: 1, value: valueK, disabled: snapshot.writable === false, "aria-label": t('contextSize'), onChange: event => { setValueK(Number(event.target.value)); }, style: {
+                            width: 76,
+                            border: '1px solid var(--dsw-alias-border-primary)',
+                            borderRadius: 5,
+                            padding: '3px 5px',
+                            color: 'var(--dsw-alias-label-primary)',
+                            background: 'var(--dsw-alias-fill-primary)',
+                            font: 'inherit',
+                            fontSize: 11,
+                        } }), _jsx("span", { style: { color: 'var(--dsw-alias-label-secondary)', fontSize: 11 }, children: "K" }), _jsx("span", { style: { color: 'var(--dsw-alias-label-secondary)', fontSize: 11 }, children: t('contextSizeDescription') })] }), configured !== undefined && (_jsx("button", { type: "button", onClick: () => { void unsetSetting('contextWindow'); }, style: {
+                    justifySelf: 'start',
+                    border: 0,
+                    padding: 0,
+                    color: 'var(--dsw-static-blue-500)',
+                    background: 'transparent',
+                    cursor: 'pointer',
+                    font: 'inherit',
+                    fontSize: 11,
+                }, children: t('contextRestore') }))] }));
+}
+export const inject = ['slots', 'locale', 'settingsScope'];
+/** Mount Fast inside the model selector and context size inside the meter panel. */
+export function apply(ctx) {
+    ctx.effect(() => ctx.locale.register(NS, { en, zh }), 'codex client: dictionaries');
+    const settings = ctx.settingsScope.bind({ namespace: SETTINGS_NAMESPACE });
+    const injected = () => ({
+        hooks: { settings },
+        setSetting: (field, value) => settings.set(field, value),
+        unsetSetting: (field) => settings.unset(field),
+    });
+    ctx.slots.inject('conversation.input.model.settings', () => ctx.slots.register({
+        name: 'conversation.input.model.settings',
+        id: 'codex-fast',
+        order: 0,
+        locale: NS,
+        inject: injected,
+    }, FastModeButton));
+    ctx.slots.inject('conversation.input.context.settings', () => ctx.slots.register({
+        name: 'conversation.input.context.settings',
+        id: 'codex-context-size',
+        order: 0,
+        locale: NS,
+        inject: injected,
+    }, ContextSizeControl));
+}
+export default { inject, apply };
+//# sourceMappingURL=index.js.map

package/lib/types/context.d.ts

@@ -0,0 +1,5 @@
+/** User-selectable Codex context controls use whole K-token units. */
+export declare const CODEX_CONTEXT_UNIT = 1000;
+export declare const CODEX_CONTEXT_MAX = 1000000;
+export declare const CODEX_PRESET_ID = "codex";
+//# sourceMappingURL=context.d.ts.map

package/lib/types/context.js

@@ -0,0 +1,5 @@
+/** User-selectable Codex context controls use whole K-token units. */
+export const CODEX_CONTEXT_UNIT = 1_000;
+export const CODEX_CONTEXT_MAX = 1_000_000;
+export const CODEX_PRESET_ID = 'codex';
+//# sourceMappingURL=context.js.map