@openclaw/codex 2026.5.27 → 2026.5.28-beta.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openclaw/codex",
-  "version": "2026.5.27",
+  "version": "2026.5.28-beta.1",
   "description": "OpenClaw Codex app-server harness and model provider plugin with a Codex-managed GPT catalog.",
   "repository": {
     "type": "git",
@@ -8,7 +8,6 @@
   },
   "type": "module",
   "dependencies": {
-    "@earendil-works/pi-coding-agent": "0.75.5",
     "@openai/codex": "0.134.0",
     "typebox": "1.1.38",
     "ws": "8.21.0",
@@ -27,10 +26,10 @@
       "minHostVersion": ">=2026.5.1-beta.1"
     },
     "compat": {
-      "pluginApi": ">=2026.5.27"
+      "pluginApi": ">=2026.5.28-beta.1"
     },
     "build": {
-      "openclawVersion": "2026.5.27"
+      "openclawVersion": "2026.5.28-beta.1"
     },
     "release": {
       "publishToClawHub": true,
@@ -47,7 +46,7 @@
     "npm-shrinkwrap.json"
   ],
   "peerDependencies": {
-    "openclaw": ">=2026.5.27"
+    "openclaw": ">=2026.5.28-beta.1"
   },
   "peerDependenciesMeta": {
     "openclaw": {

package/dist/dynamic-tools-BSZIYzfP.js

@@ -1,560 +0,0 @@
-import { E as sanitizeInlineImageDataUrl, w as invalidInlineImageText } from "./thread-lifecycle-DZAfY4d6.js";
-import { asOptionalRecord, isRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
-import { HEARTBEAT_RESPONSE_TOOL_NAME, createAgentToolResultMiddlewareRunner, createCodexAppServerToolResultExtensionRunner, embeddedAgentLog, extractToolResultMediaArtifact, filterToolResultMediaUrls, isMessagingTool, isMessagingToolSendAction, isToolWrappedWithBeforeToolCallHook, normalizeHeartbeatToolResponse, projectRuntimeToolInputSchema, runAgentHarnessAfterToolCallHook, setBeforeToolCallDiagnosticsEnabled, wrapToolWithBeforeToolCallHook } from "openclaw/plugin-sdk/agent-harness-runtime";
-import { emitTrustedDiagnosticEvent } from "openclaw/plugin-sdk/diagnostic-runtime";
-import { normalizeAgentId } from "openclaw/plugin-sdk/routing";
-//#region extensions/codex/src/app-server/dynamic-tool-profile.ts
-const CODEX_APP_SERVER_OWNED_DYNAMIC_TOOL_EXCLUDES = [
-	"read",
-	"write",
-	"edit",
-	"apply_patch",
-	"exec",
-	"process",
-	"update_plan",
-	"tool_call",
-	"tool_describe",
-	"tool_search",
-	"tool_search_code"
-];
-const DYNAMIC_TOOL_NAME_ALIASES = {
-	bash: "exec",
-	"apply-patch": "apply_patch"
-};
-function normalizeCodexDynamicToolName(name) {
-	const normalized = name.trim().toLowerCase();
-	return DYNAMIC_TOOL_NAME_ALIASES[normalized] ?? normalized;
-}
-function isForcedPrivateQaCodexRuntime(env = process.env) {
-	return env.OPENCLAW_BUILD_PRIVATE_QA === "1" && env.OPENCLAW_QA_FORCE_RUNTIME?.trim().toLowerCase() === "codex";
-}
-function resolveCodexDynamicToolsLoading(config, env = process.env) {
-	return isForcedPrivateQaCodexRuntime(env) ? "direct" : config.codexDynamicToolsLoading ?? "searchable";
-}
-function filterCodexDynamicTools(tools, config, env = process.env) {
-	const excludes = /* @__PURE__ */ new Set();
-	if (!isForcedPrivateQaCodexRuntime(env)) for (const name of CODEX_APP_SERVER_OWNED_DYNAMIC_TOOL_EXCLUDES) excludes.add(name);
-	for (const name of config.codexDynamicToolsExclude ?? []) {
-		const trimmed = normalizeCodexDynamicToolName(name);
-		if (trimmed) excludes.add(trimmed);
-	}
-	return excludes.size === 0 ? tools : tools.filter((tool) => !excludes.has(normalizeCodexDynamicToolName(tool.name)));
-}
-//#endregion
-//#region extensions/codex/src/app-server/dynamic-tools.ts
-const CODEX_OPENCLAW_DYNAMIC_TOOL_NAMESPACE = "openclaw";
-const ALWAYS_DIRECT_DYNAMIC_TOOL_NAMES = new Set(["sessions_yield"]);
-const DEFAULT_CODEX_DYNAMIC_TOOL_RESULT_MAX_CHARS = 16e3;
-function createCodexDynamicToolBridge(params) {
-	const toolResultHookContext = toToolResultHookContext(params.hookContext);
-	const toolResultMaxChars = resolveCodexDynamicToolResultMaxChars(params.hookContext);
-	const availableProjection = projectCodexDynamicTools(params.tools);
-	const registeredProjection = params.registeredTools ? projectCodexDynamicTools(params.registeredTools) : availableProjection;
-	const availableTools = availableProjection.tools.map(({ tool, inputSchema }) => {
-		if (isToolWrappedWithBeforeToolCallHook(tool)) {
-			setBeforeToolCallDiagnosticsEnabled(tool, false);
-			return {
-				tool,
-				inputSchema
-			};
-		}
-		return {
-			tool: wrapToolWithBeforeToolCallHook(tool, params.hookContext, { emitDiagnostics: false }),
-			inputSchema
-		};
-	});
-	const toolMap = new Map(availableTools.map(({ tool }) => [tool.name, tool]));
-	const registeredTools = registeredProjection.tools.map(({ tool }) => tool);
-	const registeredToolNames = new Set(registeredTools.map((tool) => tool.name));
-	const quarantinedTools = dedupeQuarantinedDynamicTools([...availableProjection.quarantinedTools, ...registeredProjection.quarantinedTools]);
-	warnQuarantinedDynamicTools(quarantinedTools);
-	emitQuarantinedDynamicToolDiagnostics(quarantinedTools, params.hookContext);
-	const telemetry = {
-		didSendViaMessagingTool: false,
-		messagingToolSentTexts: [],
-		messagingToolSentMediaUrls: [],
-		messagingToolSentTargets: [],
-		messagingToolSourceReplyPayloads: [],
-		toolMediaUrls: [],
-		toolAudioAsVoice: false,
-		quarantinedTools
-	};
-	const middlewareRunner = createAgentToolResultMiddlewareRunner({
-		runtime: "codex",
-		...toolResultHookContext
-	});
-	const legacyExtensionRunner = createCodexAppServerToolResultExtensionRunner(toolResultHookContext);
-	const directToolNames = new Set([...ALWAYS_DIRECT_DYNAMIC_TOOL_NAMES, ...params.directToolNames ?? []]);
-	return {
-		availableSpecs: availableTools.map(({ tool, inputSchema }) => createCodexDynamicToolSpec({
-			tool,
-			inputSchema,
-			loading: params.loading ?? "searchable",
-			directToolNames
-		})),
-		specs: registeredProjection.tools.map(({ tool, inputSchema }) => createCodexDynamicToolSpec({
-			tool,
-			inputSchema,
-			loading: params.loading ?? "searchable",
-			directToolNames
-		})),
-		telemetry,
-		handleToolCall: async (call, options) => {
-			const tool = toolMap.get(call.tool);
-			if (!tool) {
-				if (registeredToolNames.has(call.tool)) return {
-					contentItems: [{
-						type: "inputText",
-						text: `OpenClaw tool is not available for this turn: ${call.tool}`
-					}],
-					success: false
-				};
-				return {
-					contentItems: [{
-						type: "inputText",
-						text: `Unknown OpenClaw tool: ${call.tool}`
-					}],
-					success: false
-				};
-			}
-			const args = jsonObjectToRecord(call.arguments);
-			const startedAt = Date.now();
-			const signal = composeAbortSignals(params.signal, options?.signal);
-			let didStartExecution = false;
-			try {
-				const preparedArgs = tool.prepareArguments ? tool.prepareArguments(args) : args;
-				didStartExecution = true;
-				const rawResult = await tool.execute(call.callId, preparedArgs, signal);
-				const rawIsError = isToolResultError(rawResult);
-				const middlewareResult = await middlewareRunner.applyToolResultMiddleware({
-					threadId: call.threadId,
-					turnId: call.turnId,
-					toolCallId: call.callId,
-					toolName: tool.name,
-					args,
-					isError: rawIsError,
-					result: rawResult
-				});
-				const result = await legacyExtensionRunner.applyToolResultExtensions({
-					threadId: call.threadId,
-					turnId: call.turnId,
-					toolCallId: call.callId,
-					toolName: tool.name,
-					args,
-					result: middlewareResult
-				});
-				const resultIsError = rawIsError || isToolResultError(result);
-				collectToolTelemetry({
-					toolName: tool.name,
-					args,
-					result,
-					mediaTrustResult: rawResult,
-					telemetry,
-					isError: resultIsError
-				});
-				runAgentHarnessAfterToolCallHook({
-					toolName: tool.name,
-					toolCallId: call.callId,
-					runId: toolResultHookContext.runId,
-					agentId: toolResultHookContext.agentId,
-					sessionId: toolResultHookContext.sessionId,
-					sessionKey: toolResultHookContext.sessionKey,
-					channelId: toolResultHookContext.channelId,
-					startArgs: args,
-					result,
-					startedAt
-				});
-				const terminalType = inferToolResultDiagnosticTerminalType(result, resultIsError);
-				const response = withDiagnosticTerminalType({
-					contentItems: convertToolContents(result.content, toolResultMaxChars),
-					success: !resultIsError
-				}, terminalType);
-				withDynamicToolTermination(response, rawResult.terminate === true || result.terminate === true || isToolResultYield(rawResult) || isToolResultYield(result));
-				withDynamicToolAsyncStarted(response, isAsyncStartedToolResult(rawResult) || isAsyncStartedToolResult(result));
-				return withSideEffectEvidence(response, terminalType !== "blocked");
-			} catch (error) {
-				collectToolTelemetry({
-					toolName: tool.name,
-					args,
-					result: void 0,
-					telemetry,
-					isError: true
-				});
-				runAgentHarnessAfterToolCallHook({
-					toolName: tool.name,
-					toolCallId: call.callId,
-					runId: toolResultHookContext.runId,
-					agentId: toolResultHookContext.agentId,
-					sessionId: toolResultHookContext.sessionId,
-					sessionKey: toolResultHookContext.sessionKey,
-					channelId: toolResultHookContext.channelId,
-					startArgs: args,
-					error: error instanceof Error ? error.message : String(error),
-					startedAt
-				});
-				return withSideEffectEvidence(withDiagnosticTerminalType({
-					contentItems: [{
-						type: "inputText",
-						text: error instanceof Error ? error.message : String(error)
-					}],
-					success: false
-				}, "error"), didStartExecution);
-			}
-		}
-	};
-}
-function createCodexDynamicToolSpec(params) {
-	const base = {
-		name: params.tool.name,
-		description: params.tool.description,
-		inputSchema: params.inputSchema
-	};
-	if (params.loading === "direct" || params.directToolNames.has(params.tool.name)) return base;
-	return {
-		...base,
-		namespace: CODEX_OPENCLAW_DYNAMIC_TOOL_NAMESPACE,
-		deferLoading: true
-	};
-}
-function projectCodexDynamicTools(tools) {
-	const projectedTools = [];
-	const quarantinedTools = [];
-	for (const tool of tools) {
-		const projection = projectRuntimeToolInputSchema(tool.parameters, `${tool.name}.inputSchema`);
-		if (projection.violations.length > 0) {
-			quarantinedTools.push({
-				tool: tool.name,
-				violations: projection.violations
-			});
-			continue;
-		}
-		projectedTools.push({
-			tool,
-			inputSchema: projection.schema
-		});
-	}
-	return {
-		tools: projectedTools,
-		quarantinedTools
-	};
-}
-function warnQuarantinedDynamicTools(tools) {
-	if (tools.length === 0) return;
-	const unique = /* @__PURE__ */ new Map();
-	for (const tool of tools) unique.set(tool.tool, tool.violations);
-	embeddedAgentLog.warn(`codex app-server quarantined ${unique.size} dynamic ${unique.size === 1 ? "tool" : "tools"} with unsupported input schemas: ${[...unique.keys()].join(", ")}`, { tools: [...unique.entries()].map(([tool, violations]) => ({
-		tool,
-		violations
-	})) });
-}
-function emitQuarantinedDynamicToolDiagnostics(tools, ctx) {
-	for (const tool of tools) emitTrustedDiagnosticEvent({
-		type: "tool.execution.blocked",
-		runId: ctx?.runId,
-		sessionId: ctx?.sessionId,
-		sessionKey: ctx?.sessionKey,
-		toolName: tool.tool,
-		deniedReason: "unsupported_tool_schema",
-		reason: tool.violations.join(", ")
-	});
-}
-function dedupeQuarantinedDynamicTools(tools) {
-	return [...new Map(tools.map((tool) => [tool.tool, {
-		tool: tool.tool,
-		violations: tool.violations
-	}])).values()];
-}
-function toToolResultHookContext(ctx) {
-	const { agentId, sessionId, sessionKey, runId, channelId } = ctx ?? {};
-	return {
-		...agentId && { agentId },
-		...sessionId && { sessionId },
-		...sessionKey && { sessionKey },
-		...runId && { runId },
-		...channelId && { channelId }
-	};
-}
-function resolveCodexDynamicToolResultMaxChars(ctx) {
-	return resolveAgentContextLimitValue({
-		config: ctx?.config,
-		agentId: ctx?.agentId,
-		key: "toolResultMaxChars"
-	}) ?? DEFAULT_CODEX_DYNAMIC_TOOL_RESULT_MAX_CHARS;
-}
-function resolveAgentContextLimitValue(params) {
-	const agents = asOptionalRecord(params.config?.agents);
-	const defaultValue = readPositiveInteger(asOptionalRecord(asOptionalRecord(agents?.defaults)?.contextLimits)?.[params.key]);
-	if (!params.agentId) return defaultValue;
-	const list = agents?.list;
-	if (!Array.isArray(list)) return defaultValue;
-	const normalizedAgentId = normalizeAgentId(params.agentId);
-	return readPositiveInteger(asOptionalRecord(asOptionalRecord(list.find((entry) => {
-		const entryId = asOptionalRecord(entry)?.id;
-		return typeof entryId === "string" && normalizeAgentId(entryId) === normalizedAgentId;
-	}))?.contextLimits)?.[params.key]) ?? defaultValue;
-}
-function composeAbortSignals(...signals) {
-	const activeSignals = signals.filter((signal) => Boolean(signal));
-	if (activeSignals.length === 0) return new AbortController().signal;
-	if (activeSignals.length === 1) return activeSignals[0];
-	return AbortSignal.any(activeSignals);
-}
-function collectToolTelemetry(params) {
-	if (params.isError) return;
-	if (!params.isError && params.toolName === "cron" && isCronAddAction(params.args)) params.telemetry.successfulCronAdds = (params.telemetry.successfulCronAdds ?? 0) + 1;
-	if (!params.isError && params.toolName === HEARTBEAT_RESPONSE_TOOL_NAME) {
-		const response = normalizeHeartbeatToolResponse(params.result?.details);
-		if (response) params.telemetry.heartbeatToolResponse = response;
-	}
-	if (!params.isError && params.result) {
-		const media = extractToolResultMediaArtifact(params.result);
-		if (media) {
-			const mediaUrls = filterToolResultMediaUrls(params.toolName, media.mediaUrls, params.mediaTrustResult ?? params.result);
-			const seen = new Set(params.telemetry.toolMediaUrls);
-			for (const mediaUrl of mediaUrls) if (!seen.has(mediaUrl)) {
-				seen.add(mediaUrl);
-				params.telemetry.toolMediaUrls.push(mediaUrl);
-			}
-			if (media.audioAsVoice) params.telemetry.toolAudioAsVoice = true;
-		}
-	}
-	if (!isMessagingTool(params.toolName) || !isMessagingToolSendAction(params.toolName, params.args)) return;
-	params.telemetry.didSendViaMessagingTool = true;
-	const sourceReplyPayload = extractInternalSourceReplyPayload(params.result?.details);
-	if (sourceReplyPayload) {
-		params.telemetry.messagingToolSourceReplyPayloads.push(sourceReplyPayload);
-		return;
-	}
-	const text = readFirstString(params.args, [
-		"text",
-		"message",
-		"body",
-		"content"
-	]);
-	if (text) params.telemetry.messagingToolSentTexts.push(text);
-	const mediaUrls = collectMediaUrls(params.args);
-	params.telemetry.messagingToolSentMediaUrls.push(...mediaUrls);
-	params.telemetry.messagingToolSentTargets.push({
-		tool: params.toolName,
-		provider: readFirstString(params.args, ["provider", "channel"]) ?? params.toolName,
-		accountId: readFirstString(params.args, ["accountId", "account_id"]),
-		to: readFirstString(params.args, [
-			"to",
-			"target",
-			"recipient"
-		]),
-		threadId: readFirstString(params.args, [
-			"threadId",
-			"thread_id",
-			"messageThreadId"
-		]),
-		...text ? { text } : {},
-		...mediaUrls.length > 0 ? { mediaUrls } : {}
-	});
-}
-function extractInternalSourceReplyPayload(details) {
-	if (!isRecord(details) || details.sourceReplySink !== "internal-ui") return;
-	const rawPayload = details.sourceReply;
-	if (!isRecord(rawPayload)) return;
-	const text = readFirstString(rawPayload, ["text", "message"]);
-	const mediaUrls = collectMediaUrls(rawPayload);
-	const mediaUrl = typeof rawPayload.mediaUrl === "string" && rawPayload.mediaUrl.trim() ? rawPayload.mediaUrl.trim() : mediaUrls[0];
-	const payload = {
-		...text ? { text } : {},
-		...mediaUrl ? { mediaUrl } : {},
-		...mediaUrls.length > 0 ? { mediaUrls } : {},
-		...rawPayload.audioAsVoice === true ? { audioAsVoice: true } : {},
-		...isRecord(rawPayload.presentation) ? { presentation: rawPayload.presentation } : {},
-		...isRecord(rawPayload.interactive) ? { interactive: rawPayload.interactive } : {},
-		...isRecord(rawPayload.channelData) ? { channelData: rawPayload.channelData } : {},
-		...typeof details.idempotencyKey === "string" && details.idempotencyKey.trim() ? { idempotencyKey: details.idempotencyKey.trim() } : {}
-	};
-	return text || mediaUrls.length > 0 || payload.presentation || payload.interactive ? payload : void 0;
-}
-function readPositiveInteger(value) {
-	if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) return;
-	return Math.floor(value);
-}
-function isToolResultError(result) {
-	const details = result.details;
-	if (!isRecord(details)) return false;
-	if (details.timedOut === true) return true;
-	if (typeof details.exitCode === "number" && details.exitCode !== 0) return true;
-	if (typeof details.status !== "string") return false;
-	const status = details.status.trim().toLowerCase();
-	return status !== "" && status !== "0" && status !== "ok" && status !== "success" && status !== "completed" && status !== "recorded" && status !== "pending" && status !== "started" && status !== "running" && status !== "yielded";
-}
-function isToolResultYield(result) {
-	const details = result.details;
-	if (!isRecord(details) || typeof details.status !== "string") return false;
-	return details.status.trim().toLowerCase() === "yielded";
-}
-function isAsyncStartedToolResult(result) {
-	const details = result.details;
-	return isRecord(details) && details.async === true && details.status === "started";
-}
-function inferToolResultDiagnosticTerminalType(result, isError) {
-	const details = result.details;
-	if (isRecord(details) && typeof details.status === "string") {
-		if (details.status.trim().toLowerCase() === "blocked") return "blocked";
-	}
-	return isError ? "error" : "completed";
-}
-function withDiagnosticTerminalType(response, terminalType) {
-	Object.defineProperty(response, "diagnosticTerminalType", {
-		configurable: true,
-		enumerable: false,
-		value: terminalType
-	});
-	return response;
-}
-function withSideEffectEvidence(response, sideEffectEvidence) {
-	if (!sideEffectEvidence) return response;
-	Object.defineProperty(response, "sideEffectEvidence", {
-		configurable: true,
-		enumerable: false,
-		value: true
-	});
-	return response;
-}
-function withDynamicToolTermination(response, terminate) {
-	if (!terminate) return response;
-	Object.defineProperty(response, "terminate", {
-		configurable: true,
-		enumerable: false,
-		value: true
-	});
-	return response;
-}
-function withDynamicToolAsyncStarted(response, asyncStarted) {
-	if (!asyncStarted) return response;
-	Object.defineProperty(response, "asyncStarted", {
-		configurable: true,
-		enumerable: false,
-		value: true
-	});
-	return response;
-}
-function normalizeToolResultMaxChars(maxChars) {
-	return typeof maxChars === "number" && Number.isFinite(maxChars) && maxChars > 0 ? Math.floor(maxChars) : DEFAULT_CODEX_DYNAMIC_TOOL_RESULT_MAX_CHARS;
-}
-function convertToolContents(content, toolResultMaxChars = DEFAULT_CODEX_DYNAMIC_TOOL_RESULT_MAX_CHARS) {
-	const maxChars = normalizeToolResultMaxChars(toolResultMaxChars);
-	const totalTextChars = content.reduce((total, item) => total + (item.type === "text" ? item.text.length : 0), 0);
-	if (totalTextChars <= maxChars) return content.flatMap(convertToolContent);
-	const noticeText = `...(OpenClaw truncated dynamic tool result: original ${totalTextChars} chars, showing ${maxChars}; rerun with narrower args.)`;
-	const notice = `\n${noticeText}`;
-	let remainingTextBudget = Math.max(0, maxChars - notice.length);
-	let appendedNotice = false;
-	const output = [];
-	for (const item of content) {
-		if (item.type !== "text") {
-			output.push(...convertToolContent(item));
-			continue;
-		}
-		if (appendedNotice) continue;
-		if (notice.length >= maxChars) {
-			output.push({
-				type: "inputText",
-				text: noticeText.slice(0, maxChars)
-			});
-			appendedNotice = true;
-			continue;
-		}
-		const sliceLength = Math.min(item.text.length, remainingTextBudget);
-		remainingTextBudget -= sliceLength;
-		const shouldAppendNotice = remainingTextBudget <= 0;
-		const text = item.text.slice(0, sliceLength);
-		if (shouldAppendNotice) {
-			output.push({
-				type: "inputText",
-				text: `${text.trimEnd()}${notice}`.slice(0, maxChars)
-			});
-			appendedNotice = true;
-		} else if (text.length > 0) output.push({
-			type: "inputText",
-			text
-		});
-	}
-	if (!appendedNotice) output.push({
-		type: "inputText",
-		text: noticeText.slice(0, maxChars)
-	});
-	return output;
-}
-function convertToolContent(content) {
-	if (content.type === "text") return [{
-		type: "inputText",
-		text: content.text
-	}];
-	const imageUrl = sanitizeInlineImageDataUrl(`data:${content.mimeType};base64,${content.data}`);
-	if (!imageUrl) return [{
-		type: "inputText",
-		text: invalidInlineImageText("codex dynamic tool")
-	}];
-	return [{
-		type: "inputImage",
-		imageUrl
-	}];
-}
-function jsonObjectToRecord(value) {
-	if (!value || typeof value !== "object" || Array.isArray(value)) return {};
-	return value;
-}
-function readFirstString(record, keys) {
-	for (const key of keys) {
-		const value = record[key];
-		if (typeof value === "string" && value.trim()) return value.trim();
-		if (typeof value === "number" && Number.isFinite(value)) return String(value);
-	}
-}
-function collectMediaUrls(record) {
-	const urls = [];
-	const pushMediaUrl = (value) => {
-		if (typeof value === "string" && value.trim()) urls.push(value.trim());
-	};
-	const pushAttachment = (value) => {
-		if (!value || typeof value !== "object" || Array.isArray(value)) return;
-		const attachment = value;
-		for (const key of [
-			"media",
-			"mediaUrl",
-			"path",
-			"filePath",
-			"fileUrl",
-			"url"
-		]) pushMediaUrl(attachment[key]);
-	};
-	for (const key of [
-		"media",
-		"mediaUrl",
-		"media_url",
-		"path",
-		"filePath",
-		"fileUrl",
-		"imageUrl",
-		"image_url"
-	]) {
-		const value = record[key];
-		pushMediaUrl(value);
-	}
-	for (const key of [
-		"mediaUrls",
-		"media_urls",
-		"imageUrls",
-		"image_urls"
-	]) {
-		const value = record[key];
-		if (!Array.isArray(value)) continue;
-		for (const entry of value) pushMediaUrl(entry);
-	}
-	const attachments = record.attachments;
-	if (Array.isArray(attachments)) for (const attachment of attachments) pushAttachment(attachment);
-	return urls;
-}
-function isCronAddAction(args) {
-	const action = args.action;
-	return typeof action === "string" && action.trim().toLowerCase() === "add";
-}
-//#endregion
-export { resolveCodexDynamicToolsLoading as a, normalizeCodexDynamicToolName as i, filterCodexDynamicTools as n, isForcedPrivateQaCodexRuntime as r, createCodexDynamicToolBridge as t };

package/dist/test-api.js

@@ -1,51 +0,0 @@
-import { l as resolveCodexAppServerRuntimeOptions } from "./config-0-UN67Qg.js";
-import { a as buildDeveloperInstructions, l as buildTurnStartParams, o as buildThreadResumeParams, s as buildThreadStartParams } from "./thread-lifecycle-DZAfY4d6.js";
-import { n as filterCodexDynamicTools, t as createCodexDynamicToolBridge } from "./dynamic-tools-BSZIYzfP.js";
-//#region extensions/codex/test-api.ts
-function resolveCodexPromptSnapshotAppServerOptions(pluginConfig) {
-	return resolveCodexAppServerRuntimeOptions({
-		pluginConfig,
-		env: {},
-		requirementsToml: null
-	});
-}
-function buildCodexHarnessPromptSnapshot(params) {
-	const developerInstructions = joinPresentSections(buildDeveloperInstructions(params.attempt, { dynamicTools: params.dynamicTools }), params.developerInstructionAdditions);
-	return {
-		developerInstructions,
-		threadStartParams: buildThreadStartParams(params.attempt, {
-			cwd: params.cwd,
-			dynamicTools: params.dynamicTools,
-			appServer: params.appServer,
-			developerInstructions,
-			config: params.config
-		}),
-		threadResumeParams: buildThreadResumeParams(params.attempt, {
-			threadId: params.threadId,
-			appServer: params.appServer,
-			developerInstructions,
-			config: params.config
-		}),
-		turnStartParams: buildTurnStartParams(params.attempt, {
-			threadId: params.threadId,
-			cwd: params.cwd,
-			appServer: params.appServer,
-			promptText: params.promptText,
-			turnScopedDeveloperInstructions: params.turnScopedDeveloperInstructions,
-			heartbeatCollaborationInstructions: params.heartbeatCollaborationInstructions
-		})
-	};
-}
-function joinPresentSections(...sections) {
-	return sections.filter((section) => Boolean(section?.trim())).join("\n\n");
-}
-function createCodexDynamicToolSpecsForPromptSnapshot(params) {
-	return createCodexDynamicToolBridge({
-		tools: filterCodexDynamicTools(params.tools, params.pluginConfig ?? {}),
-		signal: new AbortController().signal,
-		loading: params.pluginConfig?.codexDynamicToolsLoading ?? "searchable",
-		directToolNames: params.directToolNames
-	}).specs;
-}
-//#endregion
-export { buildCodexHarnessPromptSnapshot, createCodexDynamicToolSpecsForPromptSnapshot, resolveCodexPromptSnapshotAppServerOptions };