@openclaw/codex 2026.7.2-beta.7 → 2026.8.1-beta.2

package/dist/isolated-completion-C58NbL40.js

@@ -0,0 +1,75 @@
+import { T as readCodexPluginConfig, h as resolveCodexAppServerHomeScope } from "./session-binding-DPxIvMgE.js";
+import { ct as isJsonObject, rt as resolveCodexAppServerPreparedAuthHandoff } from "./shared-client-kIBbGjk4.js";
+import { t as runBoundedCodexAppServerTurn } from "./bounded-turn-qgZmzy_4.js";
+import { i as createAttributedCodexAssistantMessage } from "./event-projector-assistant-message-BwxV4d6N.js";
+//#region extensions/codex/src/app-server/isolated-completion.ts
+const ISOLATED_PASSIVE_ITEM_TYPES = /* @__PURE__ */ new Set(["agentMessage", "reasoning"]);
+function assertIsolatedCompletionItems(items, prompt) {
+	let promptEchoSeen = false;
+	for (const item of items) {
+		if (ISOLATED_PASSIVE_ITEM_TYPES.has(item.type)) continue;
+		if (item.type === "userMessage" && !promptEchoSeen) {
+			const content = Array.isArray(item.content) ? item.content : [];
+			const input = content[0];
+			if (content.length === 1 && isJsonObject(input) && input.type === "text" && input.text === prompt) {
+				promptEchoSeen = true;
+				continue;
+			}
+		}
+		throw new Error(`Codex isolated completion returned unexpected native item: ${item.type}`);
+	}
+}
+/** Runs prompt-only Codex inference on an ephemeral, ring-zero native thread. */
+async function runCodexIsolatedCompletion(params, options) {
+	const authorization = params.authorization;
+	if (authorization.owner !== "harness") throw new Error("Codex native isolated completion requires harness-owned authorization.");
+	const pluginConfig = readCodexPluginConfig(options.pluginConfig);
+	const authRequirement = authorization.plan.modelRoute?.authRequirement;
+	const authHandoff = await resolveCodexAppServerPreparedAuthHandoff({
+		authRequirement,
+		authProfileId: authorization.plan.forwardedAuthProfileId,
+		authProfileStore: authorization.authProfileStore,
+		agentDir: params.agentDir,
+		homeScope: resolveCodexAppServerHomeScope({ appServer: pluginConfig.appServer }),
+		config: params.config,
+		subscriptionProfileRequiredError: "Prepared Codex subscription route requires a scoped native OAuth or token profile.",
+		subscriptionProfileUnusableError: `Prepared Codex auth profile "${authorization.plan.forwardedAuthProfileId}" is unusable.`
+	});
+	const authSelection = authHandoff.preparedAuth ? { preparedAuth: authHandoff.preparedAuth } : { profile: authHandoff.authProfileId };
+	const result = await runBoundedCodexAppServerTurn({
+		config: params.config,
+		model: {
+			mode: "required",
+			id: params.modelId
+		},
+		...authSelection,
+		authRequirement,
+		timeoutMs: params.timeoutMs,
+		signal: params.abortSignal,
+		agentDir: params.agentDir,
+		authProfileStore: authorization.authProfileStore,
+		options,
+		taskLabel: "isolated completion",
+		developerInstructions: params.systemPrompt,
+		input: [{
+			type: "text",
+			text: params.prompt,
+			text_elements: []
+		}],
+		requiredModalities: ["text"],
+		isolation: "configured-transport",
+		requireNoExternalCapabilities: true
+	});
+	assertIsolatedCompletionItems(result.items, params.prompt);
+	return { assistant: createAttributedCodexAssistantMessage({
+		api: "openai-chatgpt-responses",
+		provider: params.provider,
+		modelId: result.model
+	}, result.text, {
+		tokenUsage: result.usage,
+		aborted: false,
+		promptError: null
+	}) };
+}
+//#endregion
+export { runCodexIsolatedCompletion };

package/dist/local-runtime-attribution-B_2mnqhb.js

@@ -0,0 +1,19 @@
+import { normalizeLowercaseStringOrEmpty } from "openclaw/plugin-sdk/string-coerce-runtime";
+//#region extensions/codex/src/app-server/local-runtime-attribution.ts
+const OPENAI_PROVIDER_ID = "openai";
+const OPENAI_RESPONSES_API = "openai-responses";
+const OPENAI_CODEX_RESPONSES_API = "openai-chatgpt-responses";
+/** Maps local Codex runtime plans onto the provider/api pair exposed to event projection. */
+function resolveCodexLocalRuntimeAttribution(params) {
+	const authProfileProvider = normalizeLowercaseStringOrEmpty(params.runtimePlan?.auth?.authProfileProviderForAuth);
+	if (normalizeLowercaseStringOrEmpty(params.runtimePlan?.observability.harnessId) === "codex" && authProfileProvider !== OPENAI_PROVIDER_ID && normalizeLowercaseStringOrEmpty(params.model.provider) === OPENAI_PROVIDER_ID && normalizeLowercaseStringOrEmpty(params.model.api) === OPENAI_RESPONSES_API) return {
+		provider: OPENAI_PROVIDER_ID,
+		api: OPENAI_CODEX_RESPONSES_API
+	};
+	return {
+		provider: params.provider,
+		api: params.model.api
+	};
+}
+//#endregion
+export { resolveCodexLocalRuntimeAttribution as t };

package/dist/media-understanding-provider.js

@@ -1,5 +1,6 @@
-import { t as runBoundedCodexAppServerTurn } from "./bounded-turn-D2ZAgZVz.js";
+import { t as runBoundedCodexAppServerTurn } from "./bounded-turn-qgZmzy_4.js";
 import { validateJsonSchemaValue } from "openclaw/plugin-sdk/json-schema-runtime";
+import { isRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
 //#region extensions/codex/media-understanding-provider.ts
 /**
 * Codex-backed media understanding provider for bounded image description and
@@ -49,6 +50,7 @@ async function describeCodexImages(req, options) {
 			mode: "required",
 			id: model
 		},
+		modelProvider: "openai",
 		profile: req.profile,
 		timeoutMs: req.timeoutMs,
 		signal: req.signal,
@@ -86,6 +88,7 @@ async function extractCodexStructured(req, options) {
 			mode: "required",
 			id: model
 		},
+		modelProvider: "openai",
 		profile: req.profile,
 		timeoutMs: req.timeoutMs,
 		signal: req.signal,
@@ -138,9 +141,6 @@ function buildStructuredExtractionPrompt(req) {
 		req.jsonMode === false ? "Return the extraction as concise text." : "Return valid JSON only. Do not wrap the JSON in Markdown fences."
 	].filter((part) => Boolean(part)).join("\n\n");
 }
-function isJsonSchemaObject(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}
 function normalizeStructuredExtractionResult(params) {
 	const result = {
 		text: params.text,
@@ -154,7 +154,7 @@ function normalizeStructuredExtractionResult(params) {
 		} catch {
 			throw new Error("Codex structured extraction returned invalid JSON.");
 		}
-		if (isJsonSchemaObject(params.req.jsonSchema)) {
+		if (isRecord(params.req.jsonSchema)) {
 			const validation = validateJsonSchemaValue({
 				schema: params.req.jsonSchema,
 				cacheKey: "codex.media-understanding.extractStructured",

package/dist/{models-BBMKU4jA.js → models-BFlpn1Ex.js}

@@ -1,5 +1,5 @@
-import { x as readCodexModelListResponse } from "./transcript-mirror-DzsdNCf5.js";
-import { uniqueStrings } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { t as assertCodexModelListResponse } from "./protocol-validators-B4F7L8Rf.js";
+import { normalizeOptionalString, uniqueStrings } from "openclaw/plugin-sdk/string-coerce-runtime";
 //#region extensions/codex/src/app-server/models.ts
 /**
 * Lists and normalizes models exposed by the Codex app-server `model/list`
@@ -40,7 +40,7 @@ async function listAllCodexAppServerModels(options = {}) {
 async function withCodexAppServerModelClient(options, run) {
 	const timeoutMs = options.timeoutMs ?? 2500;
 	const useSharedClient = options.sharedClient !== false;
-	const { createIsolatedCodexAppServerClient, getLeasedSharedCodexAppServerClient, releaseLeasedSharedCodexAppServerClient } = await import("./shared-client-DTbvH-XV.js").then((n) => n.m);
+	const { createIsolatedCodexAppServerClient, getLeasedSharedCodexAppServerClient, releaseLeasedSharedCodexAppServerClient } = await import("./shared-client-kIBbGjk4.js").then((n) => n.m);
 	const client = useSharedClient ? await getLeasedSharedCodexAppServerClient({
 		startOptions: options.startOptions,
 		timeoutMs,
@@ -75,9 +75,8 @@ async function requestModelListPage(client, options) {
 }
 /** Parses a raw Codex app-server model/list response into OpenClaw's normalized shape. */
 function readModelListResult(value) {
-	const response = readCodexModelListResponse(value);
-	if (!response) return { models: [] };
-	const models = response.data.map((entry) => readCodexModel(entry)).filter((entry) => entry !== void 0);
+	const response = assertCodexModelListResponse(value);
+	const models = response.data.map((entry) => readCodexModel(entry));
 	const nextCursor = response.nextCursor ?? void 0;
 	return {
 		models,
@@ -85,27 +84,23 @@ function readModelListResult(value) {
 	};
 }
 function readCodexModel(value) {
-	const id = readNonEmptyString(value.id);
-	const model = readNonEmptyString(value.model) ?? id;
-	if (!id || !model) return;
+	const id = normalizeOptionalString(value.id);
+	const model = normalizeOptionalString(value.model);
+	if (!id || !model) throw new Error("Invalid Codex app-server model/list response: model id and name must be non-empty strings");
 	return {
 		id,
 		model,
-		...readNonEmptyString(value.displayName) ? { displayName: readNonEmptyString(value.displayName) } : {},
-		...readNonEmptyString(value.description) ? { description: readNonEmptyString(value.description) } : {},
+		...normalizeOptionalString(value.displayName) ? { displayName: normalizeOptionalString(value.displayName) } : {},
+		...normalizeOptionalString(value.description) ? { description: normalizeOptionalString(value.description) } : {},
 		hidden: value.hidden,
 		isDefault: value.isDefault,
 		inputModalities: value.inputModalities,
 		supportedReasoningEfforts: readReasoningEfforts(value.supportedReasoningEfforts),
-		...readNonEmptyString(value.defaultReasoningEffort) ? { defaultReasoningEffort: readNonEmptyString(value.defaultReasoningEffort) } : {}
+		...normalizeOptionalString(value.defaultReasoningEffort) ? { defaultReasoningEffort: normalizeOptionalString(value.defaultReasoningEffort) } : {}
 	};
 }
 function readReasoningEfforts(value) {
-	return uniqueStrings(value.map((entry) => readNonEmptyString(entry.reasoningEffort)).filter((entry) => entry !== void 0));
-}
-function readNonEmptyString(value) {
-	if (typeof value !== "string") return;
-	return value.trim() || void 0;
+	return uniqueStrings(value.map((entry) => normalizeOptionalString(entry.reasoningEffort)).filter((entry) => entry !== void 0));
 }
 function normalizeMaxPages(value) {
 	return typeof value === "number" && Number.isFinite(value) && value > 0 ? Math.floor(value) : 20;