allowsProviderAuthAvailabilityFallback: () => false,

};

function requireOnlyRow(rows: ModelRow[]): ModelRow {

expect(rows).toHaveLength(1);

const row = rows[0];

if (!row) {

throw new Error("expected one model row");

}

return row;

}

describe("appendProviderCatalogRows", () => {

it("can skip runtime model-suppression hooks for provider-catalog fast paths", async () => {

const rows: ModelRow[] = [];

models: { providers: {} },

},

});

expect(rows).toMatchObject([

{

key: "codex/gpt-5.5",

available: true,

missing: false,

},

]);

const row = requireOnlyRow(rows);

expect(row.key).toBe("codex/gpt-5.5");

expect(row.available).toBe(true);

expect(row.missing).toBe(false);

});

it("applies manifest suppression when runtime model-suppression hooks are skipped", async () => {

},

});

expect(rows).toMatchObject([

{

key: "openai/gpt-5.5",

available: true,

tags: ["configured"],

},

]);

const row = requireOnlyRow(rows);

expect(row.key).toBe("openai/gpt-5.5");

expect(row.available).toBe(true);

expect(row.tags).toEqual(["configured"]);

});

});

throw new TypeError("fetch failed", { cause });

}) as unknown as typeof fetch;

const result = await runOpenAIOAuthTlsPreflight({ fetchImpl: tlsFetchImpl, timeoutMs: 20 });

expect(result).toMatchObject({

ok: false,

kind: "tls-cert",

code: "UNABLE_TO_GET_ISSUER_CERT_LOCALLY",

});

expect(result.ok).toBe(false);

if (result.ok) {

throw new Error("expected TLS certificate preflight failure");

}

expect(result.kind).toBe("tls-cert");

expect(result.code).toBe("UNABLE_TO_GET_ISSUER_CERT_LOCALLY");

});

it("keeps generic TLS transport failures in network classification", async () => {

fetchImpl: networkFetchImpl,

timeoutMs: 20,

});

expect(result).toMatchObject({

ok: false,

kind: "network",

});

expect(result.ok).toBe(false);

if (result.ok) {

throw new Error("expected network preflight failure");

}

expect(result.kind).toBe("network");

});

});

provider: "default",

id: "CUSTOM_SEARCH_API_KEY",

});

expect(notes.map((note) => note.message)).toEqual(

expect.arrayContaining([expect.stringContaining("CUSTOM_SEARCH_API_KEY")]),

);

expect(notes.some((note) => note.message.includes("CUSTOM_SEARCH_API_KEY"))).toBe(true);

});

it("does not treat hard-disabled bundled providers as selectable credentials", () => {

expect(result.tools?.web?.search?.provider).toBe("duckduckgo");

expect(result.plugins?.entries?.duckduckgo?.enabled).toBe(true);

expect(notes).toEqual(

expect.arrayContaining([expect.stringContaining("works without an API key")]),

);

expect(notes.some((message) => message.includes("works without an API key"))).toBe(true);

});

it("uses the runtime onboarding search surface when no config is present", () => {

fs.rmSync(store);

expect(logs).toEqual(expect.arrayContaining([expect.stringContaining("Tokens (ctx %")]));

expect(logs.some((line) => line.includes("Tokens (ctx %"))).toBe(true);

const row = logs.find((line) => line.includes("+15555550123")) ?? "";

expect(row).toContain("2.0k/32k (6%)");

fs.rmSync(store);

expect(logs).toEqual(expect.arrayContaining([expect.stringContaining("Runtime")]));

expect(logs.some((line) => line.includes("Runtime"))).toBe(true);

const row = logs.find((line) => line.includes("agent:main:main")) ?? "";

expect(row).toContain("claude-opus-4-7");