{

"id": "openai",

"legacyPluginIds": ["openai-codex"],

"activation": {

"onStartup": false

},

});

it("routes setup through the OpenAI setup runtime", () => {

expect(manifest.legacyPluginIds).toEqual(["openai-codex"]);

expect(manifest.legacyPluginIds).toBeUndefined();

expect(manifest.setup?.providers?.map((provider) => provider.id)).toEqual(["openai"]);

expect(manifest.providerAuthAliases).toBeUndefined();

});

const remoteChangedGateEnv = [

"OPENCLAW_CHECK_CHANGED_REMOTE_CHILD=1",

"OPENCLAW_CHANGED_LANES_RAW_SYNC=1",

"CI=1",

];

const shellInlineCommandOptionsWithNextValue = new Set([

"+O",

const providers = Array.isArray(manifest.providers) ? manifest.providers : [];

if (providers.length > 0) {

if (manifest.providerAuthAliases?.["openai-codex"] === "openai") {

return `Adds ${displayList(providers)} model provider support to OpenClaw, including ChatGPT/Codex OAuth.`;

}

return `Adds ${displayList(providers)} model provider support to OpenClaw.`;

}

expect(buildOAuthRefreshFailureLoginCommand("openai")).toBe(

"openclaw models auth login --provider openai",

);

expect(buildOAuthRefreshFailureLoginCommand("OpenAI-Codex")).toBe(

"openclaw models auth login --provider openai",

);

});

});

const OAUTH_REFRESH_FAILURE_PROVIDER_RE = /OAuth token refresh failed for ([^:]+):/i;

const SAFE_PROVIDER_ID_RE = /^[a-z0-9][a-z0-9._-]*$/;

const RETIRED_REAUTH_PROVIDER_IDS: Readonly<Record<string, string>> = {

"openai-codex": "openai",

};

function isOAuthRefreshFailureMessage(message: string): boolean {

const lower = message.toLowerCase();

export function buildOAuthRefreshFailureLoginCommand(provider: string | null | undefined): string {

const sanitizedProvider = sanitizeOAuthRefreshFailureProvider(provider);

const reauthProvider = sanitizedProvider

? (RETIRED_REAUTH_PROVIDER_IDS[sanitizedProvider] ?? sanitizedProvider)

: null;

return reauthProvider

? formatCliCommand(`openclaw models auth login --provider ${reauthProvider}`)

return sanitizedProvider

? formatCliCommand(`openclaw models auth login --provider ${sanitizedProvider}`)

: formatCliCommand("openclaw models auth login");

}

expect(JSON.parse(lines[4])).toEqual(deliveryMirror);

});

it("repairs missing tool results in legacy OpenAI Codex transcripts", async () => {

const { file } = await createTempSessionPath();

const { header, message } = buildSessionHeaderAndMessage();

const toolCallAssistant = {

type: "message",

id: "msg-asst-legacy-process",

parentId: "msg-1",

timestamp: new Date().toISOString(),

message: {

role: "assistant",

provider: "openai-codex",

model: "gpt-5.5",

api: "openai-codex-responses",

content: [{ type: "toolCall", id: "call_process|fc_1", name: "process", arguments: {} }],

stopReason: "toolUse",

},

};

const original = `${JSON.stringify(header)}\n${JSON.stringify(message)}\n${JSON.stringify(toolCallAssistant)}\n`;

await fs.writeFile(file, original, "utf-8");

const result = await repairSessionFileIfNeeded({ sessionFile: file });

expect(result.repaired).toBe(true);

expect(result.insertedToolResults).toBe(1);

const lines = (await fs.readFile(file, "utf-8")).trimEnd().split("\n");

const inserted = JSON.parse(lines[3]);

expect(inserted.message.role).toBe("toolResult");

expect(inserted.message.toolCallId).toBe("call_process|fc_1");

});

it("does not duplicate code-mode tool results that are already persisted", async () => {

const { file } = await createTempSessionPath();

const { header, message } = buildSessionHeaderAndMessage();

provider?: unknown;

stopReason?: unknown;

};

// Persisted transcripts from the retired OpenAI Codex route still need this

// repair so replay sees a complete tool-call/tool-result pair.

const legacyOpenAIProvider = "openai-codex";

const legacyOpenAIResponsesApi = "openai-codex-responses";

const openAIProvider = message.provider === "openai" || message.provider === legacyOpenAIProvider;

const openAIResponsesApi =

message.api === "openai-chatgpt-responses" || message.api === legacyOpenAIResponsesApi;

return (

message.role === "assistant" &&

openAIResponsesApi &&

openAIProvider &&

message.api === "openai-chatgpt-responses" &&

message.provider === "openai" &&

message.stopReason !== "error" &&

message.stopReason !== "aborted"

);

const CODEX_OAUTH_WARNING_TITLE = "Codex OAuth";

const OPENAI_BASE_URL = "https://api.openai.com/v1";

const LEGACY_CODEX_APIS = new Set(["openai-responses", "openai-completions"]);

const DOCTOR_REAUTH_PROVIDER_ALIASES: Readonly<Record<string, string>> = {

[LEGACY_CODEX_PROVIDER_ID]: OPENAI_PROVIDER_ID,

};

function hasConfiguredCodexOAuthProfile(cfg: OpenClawConfig): boolean {

return Object.values(cfg.auth?.profiles ?? {}).some(

if (!classified) {

return null;

}

const provider = classified.provider ?? params.provider;

const rawProvider = classified.provider ?? params.provider;

const provider = rawProvider

? (DOCTOR_REAUTH_PROVIDER_ALIASES[rawProvider] ?? rawProvider)

: null;

const command = buildOAuthRefreshFailureLoginCommand(provider);

if (classified.reason) {

return `- ${params.profileId}: re-auth required [${formatOAuthRefreshFailureReason(classified.reason)}] — Run \`${command}\`.`;

expect(note).toHaveBeenCalledTimes(1);

const [message, title] = requireFirstMockCall(note, "doctor note") as [string, string];

expect(title).toBe("Session transcripts");

expect(message).toContain("duplicated prompt-rewrite branches");

expect(message).toContain("legacy state");

expect(message).toContain('Run "openclaw doctor --fix"');

expect(countNonEmptyLines(await fs.readFile(filePath, "utf-8"))).toBe(3);

});

it("rewrites legacy OpenAI Codex transcript metadata only during doctor repair", async () => {

const filePath = await writeTranscript([

{ type: "session", version: 3, id: "session-1", timestamp: "2026-04-25T00:00:00Z" },

{

type: "message",

id: "legacy-assistant",

parentId: null,

message: {

role: "assistant",

provider: "openai-codex",

api: "openai-codex-responses",

content: [{ type: "text", text: "hello" }],

},

},

]);

const preview = await repairBrokenSessionTranscriptFile({ filePath, shouldRepair: false });

expect(preview.broken).toBe(true);

expect(preview.repaired).toBe(false);

expect(preview.legacyOpenAICodexEntries).toBe(1);

expect(await fs.readFile(filePath, "utf-8")).toContain("openai-codex");

const result = await repairBrokenSessionTranscriptFile({ filePath, shouldRepair: true });

expect(result.broken).toBe(true);

expect(result.repaired).toBe(true);

expect(result.legacyOpenAICodexEntries).toBe(1);

const lines = (await fs.readFile(filePath, "utf-8")).trim().split(/\r?\n/);

const assistant = JSON.parse(lines[1]);

expect(assistant.message.provider).toBe("openai");

expect(assistant.message.api).toBe("openai-chatgpt-responses");

});

it("ignores ordinary branch history without internal runtime context", async () => {

const filePath = await writeTranscript([

{ type: "session", version: 3, id: "session-1", timestamp: "2026-04-25T00:00:00Z" },