@openclaw/codex 2026.5.2 → 2026.5.3-beta.2

package/dist/thread-lifecycle-BKZiIxyU.js

@@ -0,0 +1,460 @@
+import { n as codexSandboxPolicyForTurn } from "./config-CkkoMeqF.js";
+import { n as assertCodexThreadStartResponse, t as assertCodexThreadResumeResponse } from "./protocol-validators-Cpopom3_.js";
+import { t as isJsonObject } from "./protocol-C9UWI98H.js";
+import { CODEX_GPT5_HEARTBEAT_PROMPT_OVERLAY, renderCodexPromptOverlay } from "./prompt-overlay.js";
+import { isModernCodexModel } from "./provider.js";
+import { i as isCodexAppServerConnectionClosedError } from "./client-Bm5-MMSf.js";
+import { i as writeCodexAppServerBinding, n as readCodexAppServerBinding, t as clearCodexAppServerBinding } from "./session-binding-C7Y7rY0i.js";
+import { HEARTBEAT_RESPONSE_TOOL_NAME, createAgentToolResultMiddlewareRunner, createCodexAppServerToolResultExtensionRunner, embeddedAgentLog, extractToolResultMediaArtifact, filterToolResultMediaUrls, isMessagingTool, isMessagingToolSendAction, isToolWrappedWithBeforeToolCallHook, normalizeHeartbeatToolResponse, runAgentHarnessAfterToolCallHook, wrapToolWithBeforeToolCallHook } from "openclaw/plugin-sdk/agent-harness-runtime";
+//#region extensions/codex/src/app-server/dynamic-tool-profile.ts
+const CODEX_NATIVE_FIRST_DYNAMIC_TOOL_EXCLUDES = [
+	"read",
+	"write",
+	"edit",
+	"apply_patch",
+	"exec",
+	"process",
+	"update_plan"
+];
+function applyCodexDynamicToolProfile(tools, config) {
+	const excludes = /* @__PURE__ */ new Set();
+	if ((config.codexDynamicToolsProfile ?? "native-first") === "native-first") for (const name of CODEX_NATIVE_FIRST_DYNAMIC_TOOL_EXCLUDES) excludes.add(name);
+	for (const name of config.codexDynamicToolsExclude ?? []) {
+		const trimmed = name.trim();
+		if (trimmed) excludes.add(trimmed);
+	}
+	return excludes.size === 0 ? tools : tools.filter((tool) => !excludes.has(tool.name));
+}
+//#endregion
+//#region extensions/codex/src/app-server/dynamic-tools.ts
+function createCodexDynamicToolBridge(params) {
+	const tools = params.tools.map((tool) => isToolWrappedWithBeforeToolCallHook(tool) ? tool : wrapToolWithBeforeToolCallHook(tool, params.hookContext));
+	const toolMap = new Map(tools.map((tool) => [tool.name, tool]));
+	const telemetry = {
+		didSendViaMessagingTool: false,
+		messagingToolSentTexts: [],
+		messagingToolSentMediaUrls: [],
+		messagingToolSentTargets: [],
+		toolMediaUrls: [],
+		toolAudioAsVoice: false
+	};
+	const middlewareRunner = createAgentToolResultMiddlewareRunner({
+		runtime: "codex",
+		...params.hookContext
+	});
+	const legacyExtensionRunner = createCodexAppServerToolResultExtensionRunner(params.hookContext ?? {});
+	return {
+		specs: tools.map((tool) => ({
+			name: tool.name,
+			description: tool.description,
+			inputSchema: toJsonValue(tool.parameters)
+		})),
+		telemetry,
+		handleToolCall: async (call, options) => {
+			const tool = toolMap.get(call.tool);
+			if (!tool) 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);
+			try {
+				const preparedArgs = tool.prepareArguments ? tool.prepareArguments(args) : args;
+				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
+				});
+				collectToolTelemetry({
+					toolName: tool.name,
+					args,
+					result,
+					mediaTrustResult: rawResult,
+					telemetry,
+					isError: rawIsError || isToolResultError(result)
+				});
+				runAgentHarnessAfterToolCallHook({
+					toolName: tool.name,
+					toolCallId: call.callId,
+					runId: params.hookContext?.runId,
+					agentId: params.hookContext?.agentId,
+					sessionId: params.hookContext?.sessionId,
+					sessionKey: params.hookContext?.sessionKey,
+					startArgs: args,
+					result,
+					startedAt
+				});
+				return {
+					contentItems: result.content.flatMap(convertToolContent),
+					success: true
+				};
+			} catch (error) {
+				collectToolTelemetry({
+					toolName: tool.name,
+					args,
+					result: void 0,
+					telemetry,
+					isError: true
+				});
+				runAgentHarnessAfterToolCallHook({
+					toolName: tool.name,
+					toolCallId: call.callId,
+					runId: params.hookContext?.runId,
+					agentId: params.hookContext?.agentId,
+					sessionId: params.hookContext?.sessionId,
+					sessionKey: params.hookContext?.sessionKey,
+					startArgs: args,
+					error: error instanceof Error ? error.message : String(error),
+					startedAt
+				});
+				return {
+					contentItems: [{
+						type: "inputText",
+						text: error instanceof Error ? error.message : String(error)
+					}],
+					success: false
+				};
+			}
+		}
+	};
+}
+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 text = readFirstString(params.args, [
+		"text",
+		"message",
+		"body",
+		"content"
+	]);
+	if (text) params.telemetry.messagingToolSentTexts.push(text);
+	params.telemetry.messagingToolSentMediaUrls.push(...collectMediaUrls(params.args));
+	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"
+		])
+	});
+}
+function isRecord(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(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 !== "running";
+}
+function convertToolContent(content) {
+	if (content.type === "text") return [{
+		type: "inputText",
+		text: content.text
+	}];
+	return [{
+		type: "inputImage",
+		imageUrl: `data:${content.mimeType};base64,${content.data}`
+	}];
+}
+function toJsonValue(value) {
+	try {
+		const text = JSON.stringify(value);
+		if (!text) return {};
+		return JSON.parse(text);
+	} catch {
+		return {};
+	}
+}
+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 = [];
+	for (const key of [
+		"mediaUrl",
+		"media_url",
+		"imageUrl",
+		"image_url"
+	]) {
+		const value = record[key];
+		if (typeof value === "string" && value.trim()) urls.push(value.trim());
+	}
+	for (const key of [
+		"mediaUrls",
+		"media_urls",
+		"imageUrls",
+		"image_urls"
+	]) {
+		const value = record[key];
+		if (!Array.isArray(value)) continue;
+		for (const entry of value) if (typeof entry === "string" && entry.trim()) urls.push(entry.trim());
+	}
+	return urls;
+}
+function isCronAddAction(args) {
+	const action = args.action;
+	return typeof action === "string" && action.trim().toLowerCase() === "add";
+}
+//#endregion
+//#region extensions/codex/src/app-server/thread-lifecycle.ts
+async function startOrResumeThread(params) {
+	const dynamicToolsFingerprint = fingerprintDynamicTools(params.dynamicTools);
+	const binding = await readCodexAppServerBinding(params.params.sessionFile);
+	if (binding?.threadId) if (binding.dynamicToolsFingerprint && binding.dynamicToolsFingerprint !== dynamicToolsFingerprint) {
+		embeddedAgentLog.debug("codex app-server dynamic tool catalog changed; starting a new thread", { threadId: binding.threadId });
+		await clearCodexAppServerBinding(params.params.sessionFile);
+	} else try {
+		const response = assertCodexThreadResumeResponse(await params.client.request("thread/resume", buildThreadResumeParams(params.params, {
+			threadId: binding.threadId,
+			appServer: params.appServer,
+			developerInstructions: params.developerInstructions,
+			config: params.config
+		})));
+		const boundAuthProfileId = params.params.authProfileId ?? binding.authProfileId;
+		const fallbackModelProvider = resolveCodexAppServerModelProvider(params.params.provider);
+		await writeCodexAppServerBinding(params.params.sessionFile, {
+			threadId: response.thread.id,
+			cwd: params.cwd,
+			authProfileId: boundAuthProfileId,
+			model: params.params.modelId,
+			modelProvider: response.modelProvider ?? fallbackModelProvider,
+			dynamicToolsFingerprint,
+			createdAt: binding.createdAt
+		});
+		return {
+			...binding,
+			threadId: response.thread.id,
+			cwd: params.cwd,
+			authProfileId: boundAuthProfileId,
+			model: params.params.modelId,
+			modelProvider: response.modelProvider ?? fallbackModelProvider,
+			dynamicToolsFingerprint
+		};
+	} catch (error) {
+		if (isCodexAppServerConnectionClosedError(error)) throw error;
+		embeddedAgentLog.warn("codex app-server thread resume failed; starting a new thread", { error });
+		await clearCodexAppServerBinding(params.params.sessionFile);
+	}
+	const response = assertCodexThreadStartResponse(await params.client.request("thread/start", buildThreadStartParams(params.params, {
+		cwd: params.cwd,
+		dynamicTools: params.dynamicTools,
+		appServer: params.appServer,
+		developerInstructions: params.developerInstructions,
+		config: params.config
+	})));
+	const modelProvider = resolveCodexAppServerModelProvider(params.params.provider);
+	const createdAt = (/* @__PURE__ */ new Date()).toISOString();
+	await writeCodexAppServerBinding(params.params.sessionFile, {
+		threadId: response.thread.id,
+		cwd: params.cwd,
+		authProfileId: params.params.authProfileId,
+		model: response.model ?? params.params.modelId,
+		modelProvider: response.modelProvider ?? modelProvider,
+		dynamicToolsFingerprint,
+		createdAt
+	});
+	return {
+		schemaVersion: 1,
+		threadId: response.thread.id,
+		sessionFile: params.params.sessionFile,
+		cwd: params.cwd,
+		authProfileId: params.params.authProfileId,
+		model: response.model ?? params.params.modelId,
+		modelProvider: response.modelProvider ?? modelProvider,
+		dynamicToolsFingerprint,
+		createdAt,
+		updatedAt: createdAt
+	};
+}
+function buildThreadStartParams(params, options) {
+	const modelProvider = resolveCodexAppServerModelProvider(params.provider);
+	return {
+		model: params.modelId,
+		...modelProvider ? { modelProvider } : {},
+		cwd: options.cwd,
+		approvalPolicy: options.appServer.approvalPolicy,
+		approvalsReviewer: options.appServer.approvalsReviewer,
+		sandbox: options.appServer.sandbox,
+		...options.appServer.serviceTier ? { serviceTier: options.appServer.serviceTier } : {},
+		serviceName: "OpenClaw",
+		...options.config ? { config: options.config } : {},
+		developerInstructions: options.developerInstructions ?? buildDeveloperInstructions(params),
+		dynamicTools: options.dynamicTools,
+		experimentalRawEvents: true,
+		persistExtendedHistory: true
+	};
+}
+function buildThreadResumeParams(params, options) {
+	const modelProvider = resolveCodexAppServerModelProvider(params.provider);
+	return {
+		threadId: options.threadId,
+		model: params.modelId,
+		...modelProvider ? { modelProvider } : {},
+		approvalPolicy: options.appServer.approvalPolicy,
+		approvalsReviewer: options.appServer.approvalsReviewer,
+		sandbox: options.appServer.sandbox,
+		...options.appServer.serviceTier ? { serviceTier: options.appServer.serviceTier } : {},
+		...options.config ? { config: options.config } : {},
+		developerInstructions: options.developerInstructions ?? buildDeveloperInstructions(params),
+		persistExtendedHistory: true
+	};
+}
+function buildTurnStartParams(params, options) {
+	return {
+		threadId: options.threadId,
+		input: buildUserInput(params, options.promptText),
+		cwd: options.cwd,
+		approvalPolicy: options.appServer.approvalPolicy,
+		approvalsReviewer: options.appServer.approvalsReviewer,
+		sandboxPolicy: codexSandboxPolicyForTurn(options.appServer.sandbox, options.cwd),
+		model: params.modelId,
+		...options.appServer.serviceTier ? { serviceTier: options.appServer.serviceTier } : {},
+		effort: resolveReasoningEffort(params.thinkLevel, params.modelId),
+		collaborationMode: buildTurnCollaborationMode(params)
+	};
+}
+function buildTurnCollaborationMode(params) {
+	return {
+		mode: "default",
+		settings: {
+			model: params.modelId,
+			reasoning_effort: resolveReasoningEffort(params.thinkLevel, params.modelId),
+			developer_instructions: params.trigger === "heartbeat" ? buildHeartbeatCollaborationInstructions() : null
+		}
+	};
+}
+function buildHeartbeatCollaborationInstructions() {
+	return ["This is an OpenClaw heartbeat turn. Apply these instructions only to this heartbeat wake; ordinary chat turns should stay in Codex Default mode.", CODEX_GPT5_HEARTBEAT_PROMPT_OVERLAY].join("\n\n");
+}
+function fingerprintDynamicTools(dynamicTools) {
+	return JSON.stringify(dynamicTools.map(fingerprintDynamicToolSpec));
+}
+function fingerprintDynamicToolSpec(tool) {
+	if (!isJsonObject(tool)) return stabilizeJsonValue(tool);
+	const stable = {};
+	for (const [key, child] of Object.entries(tool).toSorted(([left], [right]) => left.localeCompare(right))) {
+		if (key === "description") continue;
+		stable[key] = stabilizeJsonValue(child);
+	}
+	return stable;
+}
+function stabilizeJsonValue(value) {
+	if (Array.isArray(value)) return value.map(stabilizeJsonValue);
+	if (!isJsonObject(value)) return value;
+	const stable = {};
+	for (const [key, child] of Object.entries(value).toSorted(([left], [right]) => left.localeCompare(right))) stable[key] = stabilizeJsonValue(child);
+	return stable;
+}
+function buildDeveloperInstructions(params) {
+	return [
+		"You are running inside OpenClaw. Use OpenClaw dynamic tools for OpenClaw-specific integrations such as messaging, cron, sessions, media, gateway, and nodes when available.",
+		"Preserve the user's existing channel/session context. If sending a channel reply, use the OpenClaw messaging tool instead of describing that you would reply.",
+		renderCodexRuntimePromptOverlay(params),
+		params.extraSystemPrompt,
+		params.skillsSnapshot?.prompt
+	].filter((section) => typeof section === "string" && section.trim()).join("\n\n");
+}
+function renderCodexRuntimePromptOverlay(params) {
+	const contribution = params.runtimePlan?.prompt.resolveSystemPromptContribution({
+		config: params.config,
+		agentDir: params.agentDir,
+		workspaceDir: params.workspaceDir,
+		provider: params.provider,
+		modelId: params.modelId,
+		promptMode: "full",
+		agentId: params.agentId
+	});
+	if (!contribution) return renderCodexPromptOverlay({
+		config: params.config,
+		providerId: params.provider,
+		modelId: params.modelId
+	});
+	return [
+		contribution.stablePrefix,
+		...Object.values(contribution.sectionOverrides ?? {}),
+		contribution.dynamicSuffix
+	].filter((section) => typeof section === "string" && section.trim().length > 0).join("\n\n");
+}
+function buildUserInput(params, promptText = params.prompt) {
+	return [{
+		type: "text",
+		text: promptText,
+		text_elements: []
+	}, ...(params.images ?? []).map((image) => ({
+		type: "image",
+		url: `data:${image.mimeType};base64,${image.data}`
+	}))];
+}
+function resolveCodexAppServerModelProvider(provider) {
+	const normalized = provider.trim();
+	if (!normalized || normalized === "codex") return;
+	return normalized === "openai-codex" ? "openai" : normalized;
+}
+function resolveReasoningEffort(thinkLevel, modelId) {
+	if (thinkLevel === "minimal") return isModernCodexModel(modelId) ? "low" : "minimal";
+	if (thinkLevel === "low" || thinkLevel === "medium" || thinkLevel === "high" || thinkLevel === "xhigh") return thinkLevel;
+	return null;
+}
+//#endregion
+export { startOrResumeThread as a, buildTurnStartParams as i, buildThreadResumeParams as n, createCodexDynamicToolBridge as o, buildThreadStartParams as r, applyCodexDynamicToolProfile as s, buildDeveloperInstructions as t };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openclaw/codex",
-  "version": "2026.5.2",
+  "version": "2026.5.3-beta.2",
   "description": "OpenClaw Codex harness and model provider plugin",
   "repository": {
     "type": "git",
@@ -27,14 +27,29 @@
       "minHostVersion": ">=2026.5.1-beta.1"
     },
     "compat": {
-      "pluginApi": ">=2026.5.2"
+      "pluginApi": ">=2026.5.3-beta.2"
     },
     "build": {
-      "openclawVersion": "2026.5.2"
+      "openclawVersion": "2026.5.3-beta.2"
     },
     "release": {
       "publishToClawHub": true,
       "publishToNpm": true
+    },
+    "runtimeExtensions": [
+      "./dist/index.js"
+    ]
+  },
+  "files": [
+    "dist/**",
+    "openclaw.plugin.json"
+  ],
+  "peerDependencies": {
+    "openclaw": ">=2026.5.3-beta.2"
+  },
+  "peerDependenciesMeta": {
+    "openclaw": {
+      "optional": true
     }
   }
 }

package/harness.ts

@@ -1,59 +0,0 @@
-import type { AgentHarness } from "openclaw/plugin-sdk/agent-harness-runtime";
-import type {
-  CodexAppServerListModelsOptions,
-  CodexAppServerModel,
-  CodexAppServerModelListResult,
-} from "./src/app-server/models.js";
-
-const DEFAULT_CODEX_HARNESS_PROVIDER_IDS = new Set(["codex"]);
-
-export type { CodexAppServerListModelsOptions, CodexAppServerModel, CodexAppServerModelListResult };
-
-export function createCodexAppServerAgentHarness(options?: {
-  id?: string;
-  label?: string;
-  providerIds?: Iterable<string>;
-  pluginConfig?: unknown;
-}): AgentHarness {
-  const providerIds = new Set(
-    [...(options?.providerIds ?? DEFAULT_CODEX_HARNESS_PROVIDER_IDS)].map((id) =>
-      id.trim().toLowerCase(),
-    ),
-  );
-  return {
-    id: options?.id ?? "codex",
-    label: options?.label ?? "Codex agent harness",
-    deliveryDefaults: {
-      sourceVisibleReplies: "message_tool",
-    },
-    supports: (ctx) => {
-      const provider = ctx.provider.trim().toLowerCase();
-      if (providerIds.has(provider)) {
-        return { supported: true, priority: 100 };
-      }
-      return {
-        supported: false,
-        reason: `provider is not one of: ${[...providerIds].toSorted().join(", ")}`,
-      };
-    },
-    runAttempt: async (params) => {
-      const { runCodexAppServerAttempt } = await import("./src/app-server/run-attempt.js");
-      return runCodexAppServerAttempt(params, { pluginConfig: options?.pluginConfig });
-    },
-    compact: async (params) => {
-      const { maybeCompactCodexAppServerSession } = await import("./src/app-server/compact.js");
-      return maybeCompactCodexAppServerSession(params, { pluginConfig: options?.pluginConfig });
-    },
-    reset: async (params) => {
-      if (params.sessionFile) {
-        const { clearCodexAppServerBinding } = await import("./src/app-server/session-binding.js");
-        await clearCodexAppServerBinding(params.sessionFile);
-      }
-    },
-    dispose: async () => {
-      const { clearSharedCodexAppServerClientAndWait } =
-        await import("./src/app-server/shared-client.js");
-      await clearSharedCodexAppServerClientAndWait();
-    },
-  };
-}

package/index.test.ts

@@ -1,106 +0,0 @@
-import fs from "node:fs";
-import { createTestPluginApi } from "openclaw/plugin-sdk/plugin-test-api";
-import { describe, expect, it, vi } from "vitest";
-import { createCodexAppServerAgentHarness } from "./harness.js";
-import plugin from "./index.js";
-
-describe("codex plugin", () => {
-  it("is opt-in by default", () => {
-    const manifest = JSON.parse(
-      fs.readFileSync(new URL("./openclaw.plugin.json", import.meta.url), "utf8"),
-    ) as { enabledByDefault?: unknown };
-
-    expect(manifest.enabledByDefault).toBeUndefined();
-  });
-
-  it("registers the codex provider and agent harness", () => {
-    const registerAgentHarness = vi.fn();
-    const registerCommand = vi.fn();
-    const registerMediaUnderstandingProvider = vi.fn();
-    const registerMigrationProvider = vi.fn();
-    const registerProvider = vi.fn();
-    const on = vi.fn();
-    const onConversationBindingResolved = vi.fn();
-
-    plugin.register(
-      createTestPluginApi({
-        id: "codex",
-        name: "Codex",
-        source: "test",
-        config: {},
-        pluginConfig: {},
-        runtime: {} as never,
-        registerAgentHarness,
-        registerCommand,
-        registerMediaUnderstandingProvider,
-        registerMigrationProvider,
-        registerProvider,
-        on,
-        onConversationBindingResolved,
-      }),
-    );
-
-    expect(registerProvider.mock.calls[0]?.[0]).toMatchObject({ id: "codex", label: "Codex" });
-    expect(registerAgentHarness.mock.calls[0]?.[0]).toMatchObject({
-      id: "codex",
-      label: "Codex agent harness",
-      deliveryDefaults: { sourceVisibleReplies: "message_tool" },
-      dispose: expect.any(Function),
-    });
-    expect(registerMediaUnderstandingProvider.mock.calls[0]?.[0]).toMatchObject({
-      id: "codex",
-      capabilities: ["image"],
-      defaultModels: { image: "gpt-5.5" },
-      describeImage: expect.any(Function),
-      describeImages: expect.any(Function),
-    });
-    expect(registerCommand.mock.calls[0]?.[0]).toMatchObject({
-      name: "codex",
-      description: "Inspect and control the Codex app-server harness",
-    });
-    expect(registerMigrationProvider.mock.calls[0]?.[0]).toMatchObject({
-      id: "codex",
-      label: "Codex",
-    });
-    expect(on).toHaveBeenCalledWith("inbound_claim", expect.any(Function));
-    expect(onConversationBindingResolved).toHaveBeenCalledWith(expect.any(Function));
-  });
-
-  it("registers with capture APIs that do not expose conversation binding hooks yet", () => {
-    const api = createTestPluginApi({
-      id: "codex",
-      name: "Codex",
-      source: "test",
-      config: {},
-      pluginConfig: {},
-      runtime: {} as never,
-      registerAgentHarness: vi.fn(),
-      registerCommand: vi.fn(),
-      registerMediaUnderstandingProvider: vi.fn(),
-      registerProvider: vi.fn(),
-      on: vi.fn(),
-    }) as ReturnType<typeof createTestPluginApi> & {
-      onConversationBindingResolved?: ReturnType<typeof vi.fn>;
-    };
-    delete (api as { onConversationBindingResolved?: unknown }).onConversationBindingResolved;
-
-    expect(() => plugin.register(api)).not.toThrow();
-  });
-
-  it("only claims the codex provider by default", () => {
-    const harness = createCodexAppServerAgentHarness();
-
-    expect(harness.deliveryDefaults?.sourceVisibleReplies).toBe("message_tool");
-    expect(
-      harness.supports({ provider: "codex", modelId: "gpt-5.4", requestedRuntime: "auto" })
-        .supported,
-    ).toBe(true);
-    expect(
-      harness.supports({
-        provider: "openai-codex",
-        modelId: "gpt-5.4",
-        requestedRuntime: "auto",
-      }),
-    ).toMatchObject({ supported: false });
-  });
-});