};

}

describe("Codex thread response validators", () => {

it("normalizes missing sessionId from id for start and resume responses", () => {

for (const assertResponse of [

assertCodexThreadStartResponse,

assertCodexThreadResumeResponse,

]) {

const response = makeMinimalResponse({ sessionId: undefined });

delete (response.thread as Record<string, unknown>).sessionId;

const result = assertResponse(response);

expect(result.thread.id).toBe("thread-1");

expect(result.thread.sessionId).toBe("thread-1");

}

});

});

describe("assertCodexThreadStartResponse", () => {

it("accepts response with both id and sessionId", () => {

const response = makeMinimalResponse();

expect(result.thread.sessionId).toBe("session-1");

});

it("normalizes missing sessionId from id", () => {

const response = makeMinimalResponse({ sessionId: undefined });

// Remove the sessionId key entirely

delete (response.thread as Record<string, unknown>).sessionId;

const result = assertCodexThreadStartResponse(response);

expect(result.thread.id).toBe("thread-1");

expect(result.thread.sessionId).toBe("thread-1");

});

it("normalizes missing id from sessionId", () => {

const response = makeMinimalResponse({ id: undefined, sessionId: "session-1" });

delete (response.thread as Record<string, unknown>).id;

});

});

describe("assertCodexThreadResumeResponse", () => {

it("normalizes missing sessionId from id", () => {

const response = makeMinimalResponse({ sessionId: undefined });

delete (response.thread as Record<string, unknown>).sessionId;

const result = assertCodexThreadResumeResponse(response);

expect(result.thread.id).toBe("thread-1");

expect(result.thread.sessionId).toBe("thread-1");

});

});

describe("readCodexModelListResponse", () => {

it("applies defaults from generated schemas behind local refs", () => {

const response = readCodexModelListResponse({

});

it("fails closed before raw app-server bypass methods when exec host=node is active", async () => {

await expect(

requestCodexAppServerJson({

method: "command/exec",

requestParams: { command: ["sh", "-lc", "id"] },

config: { tools: { exec: { host: "node", node: "worker-1" } } },

sessionKey: "node-session",

}),

).rejects.toThrow(

"Codex-native app-server method `command/exec` is unavailable because OpenClaw exec host=node is active for this session.",

);

for (const method of ["command/exec", "process/spawn"]) {

await expect(

requestCodexAppServerJson({

method,

requestParams: { command: ["sh", "-lc", "id"] },

config: { tools: { exec: { host: "node", node: "worker-1" } } },

sessionKey: "node-session",

}),

).rejects.toThrow(

`Codex-native app-server method \`${method}\` is unavailable because OpenClaw exec host=node is active for this session.`,

);

}

expect(sharedClientMocks.getSharedCodexAppServerClient).not.toHaveBeenCalled();

});

expect(request).toHaveBeenCalledWith("thread/list", { limit: 10 }, { timeoutMs: 60_000 });

});

it("fails closed before raw app-server bypass methods when exec host=node is active", async () => {

await expect(

requestCodexAppServerJson({

method: "process/spawn",

requestParams: { command: ["sh", "-lc", "id"] },

config: { tools: { exec: { host: "node", node: "worker-1" } } },

sessionKey: "node-session",

}),

).rejects.toThrow(

"Codex-native app-server method `process/spawn` is unavailable because OpenClaw exec host=node is active for this session.",

);

expect(sharedClientMocks.getSharedCodexAppServerClient).not.toHaveBeenCalled();

});

it("fails closed for config-level exec host=node even without a session key", async () => {

await expect(

requestCodexAppServerJson({

},

});

async function withLiveFetch(

mockFetch: ReturnType<typeof vi.fn>,

run: () => Promise<void>,

) {

async function withLiveFetch(mockFetch: ReturnType<typeof vi.fn>, run: () => Promise<void>) {

const env = { ...process.env };

delete process.env.NODE_ENV;

delete process.env.VITEST;

}

}

describe("listDeepInfraImageGenCatalog", () => {

it("returns null when no discoveryApiKey is configured", async () => {

const result = await listDeepInfraImageGenCatalog(makeCtx());

expect(result).toBeNull();

describe("DeepInfra generation catalogs", () => {

it("return null when no discoveryApiKey is configured", async () => {

await expect(listDeepInfraImageGenCatalog(makeCtx())).resolves.toBeNull();

await expect(listDeepInfraVideoGenCatalog(makeCtx())).resolves.toBeNull();

});

});

describe("listDeepInfraImageGenCatalog", () => {

it("returns null when live discovery succeeds but the response has zero image-gen entries", async () => {

const mockFetch = vi.fn().mockResolvedValue({

ok: true,

});

describe("listDeepInfraVideoGenCatalog", () => {

it("returns null when no discoveryApiKey is configured", async () => {

const result = await listDeepInfraVideoGenCatalog(makeCtx());

expect(result).toBeNull();

});

it("returns null when live discovery succeeds but the response has zero video-gen entries", async () => {

// Current production state: TTS/STT/T2V models lack the OPENAI tag the

// backend filter requires, so a key-authenticated discovery still

await withLiveFetch(mockFetch, async () => {

const result = await listDeepInfraVideoGenCatalog(withKeyCtx());

expect(result).not.toBeNull();

expect(result?.map((e) => e.model)).toEqual([

"Wan-AI/Wan2.6-T2V",

"ByteDance/Seedance-2.0",

]);

expect(result?.map((e) => e.model)).toEqual(["Wan-AI/Wan2.6-T2V", "ByteDance/Seedance-2.0"]);

const first = result?.[0];

expect(first?.kind).toBe("video_generation");

expect(first?.capabilities?.generate?.supportsAspectRatio).toBe(true);

emoji: "👍",

targetAuthor: "+15550001111",

targetTimestamp: 1699999999999,

groupId: "group-123",

});

expect(result).toEqual({ timestamp: 1700000000000 });

reaction: "👍",

target_author: "+15550001111",

timestamp: 1699999999999,

group_id: "group-123",

}),

);

});

it("includes group_id when provided", async () => {

mockFetch.mockResolvedValue({

ok: true,

status: 200,

text: async () => JSON.stringify({}),

});

await containerSendReaction({

baseUrl: "http://localhost:8080",

account: "+14259798283",

recipient: "+15550001111",

emoji: "❤️",

targetAuthor: "+15550001111",

targetTimestamp: 1699999999999,

groupId: "group-123",

});

const body = parseFetchBody();

expect(body.group_id).toBe("group-123");

});

});

describe("containerRpcRequest reactions", () => {

emoji: "👍",

targetAuthor: "+15550001111",

targetTimestamp: 1699999999999,

groupId: "group-123",

});

expect(result).toEqual({ timestamp: 1700000000000 });

reaction: "👍",

target_author: "+15550001111",

timestamp: 1699999999999,

group_id: "group-123",

}),

);

});

it("includes group_id when provided", async () => {

mockFetch.mockResolvedValue({

ok: true,

status: 200,

text: async () => JSON.stringify({}),

});

await containerRemoveReaction({

baseUrl: "http://localhost:8080",

account: "+14259798283",

recipient: "+15550001111",

emoji: "❤️",

targetAuthor: "+15550001111",

targetTimestamp: 1699999999999,

groupId: "group-123",

});

const body = parseFetchBody();

expect(body.group_id).toBe("group-123");

});

});