async collectRuntimeToolSchemaFindings() {

return [];

},

async collectProviderCatalogProjectionFindings() {

return [];

},

...overrides,

};

}

}),

);

});

it("reports active provider catalog projection findings", async () => {

const check = getCheck(

createCoreHealthChecks(

createDeps({

async collectProviderCatalogProjectionFindings(): Promise<readonly HealthFinding[]> {

return [

{

checkId: "core/doctor/provider-catalog-projection",

severity: "error",

message:

"Provider catalog mockplugin cannot be projected into the unified text model catalog.",

path: "plugins.entries.mockplugin",

target: "mockplugin",

requirement: "mockplugin provider catalog entry read failed",

},

];

},

}),

),

"core/doctor/provider-catalog-projection",

);

await expect(

check.detect({

mode: "doctor",

runtime,

cfg: {},

}),

).resolves.toContainEqual(

expect.objectContaining({

checkId: "core/doctor/provider-catalog-projection",

severity: "error",

target: "mockplugin",

}),

);

});

});

readonly collectRuntimeToolSchemaFindings: (

ctx: HealthCheckContext,

) => Promise<readonly HealthFinding[]>;

readonly collectProviderCatalogProjectionFindings: (

ctx: HealthCheckContext,

) => Promise<readonly HealthFinding[]>;

};

async function detectUnavailableSkillsWithRuntime(

return runtime.collectRuntimeToolSchemaFindings(ctx.cfg);

}

async function collectProviderCatalogProjectionFindingsWithRuntime(

ctx: HealthCheckContext,

): Promise<readonly HealthFinding[]> {

const runtime = await loadDoctorCoreChecksRuntimeModule();

return runtime.collectProviderCatalogProjectionFindings(ctx.cfg);

}

const defaultCoreHealthCheckDeps: CoreHealthCheckDeps = {

detectUnavailableSkills: detectUnavailableSkillsWithRuntime,

collectSecurityWarnings: collectSecurityWarningsWithRuntime,

collectWorkspaceSuggestionNotes: collectWorkspaceSuggestionNotesWithRuntime,

collectRuntimeToolSchemaFindings: collectRuntimeToolSchemaFindingsWithRuntime,

collectProviderCatalogProjectionFindings: collectProviderCatalogProjectionFindingsWithRuntime,

};

export function configValidationIssuesToHealthFindings(

};

}

function createProviderCatalogProjectionCheck(deps: CoreHealthCheckDeps): HealthCheck {

return {

id: "core/doctor/provider-catalog-projection",

kind: "core",

description: "Provider catalog hooks project into unified text model catalog rows.",

source: "doctor",

async detect(ctx) {

return deps.collectProviderCatalogProjectionFindings(ctx);

},

};

}

function normalizeDoctorNoteLine(line: string): string {

return line.replace(/^- /, "").trim();

}

openAIOAuthTlsCheck,

hooksModelCheck,

bootstrapSizeCheck,

createProviderCatalogProjectionCheck(deps),

createRuntimeToolSchemaCheck(deps),

createWorkspaceSuggestionsCheck(deps),

];

);

});

it("reports provider catalog projection blockers during normal doctor runs", async () => {

const contribution = requireDoctorContribution("doctor:provider-catalog-projection");

mocks.getHealthCheck.mockReturnValue({

id: "core/doctor/provider-catalog-projection",

detect: vi.fn(async () => [

{

checkId: "core/doctor/provider-catalog-projection",

severity: "error",

message:

"Provider catalog mockplugin cannot be projected into the unified text model catalog.",

path: "plugins.entries.mockplugin",

target: "mockplugin",

requirement: "provider catalog entry read failed",

fixHint:

"Fix the plugin provider catalog hook or disable the plugin, then rerun doctor before relying on model discovery.",

},

]),

});

const ctx = {

cfg: {},

configResult: { cfg: {} },

sourceConfigValid: true,

prompter: buildDoctorPrompter(false),

runtime: { log: vi.fn(), error: vi.fn(), exit: vi.fn() },

options: {},

cfgForPersistence: {},

configPath: "/tmp/fake-openclaw.json",

env: {},

} as Parameters<(typeof contribution)["run"]>[0];

await contribution.run(ctx);

expect(ctx.healthOk).toBe(false);

expect(mocks.note).toHaveBeenCalledWith(

expect.stringContaining("Provider catalog mockplugin cannot be projected"),

"Doctor warnings",

);

expect(mocks.note).toHaveBeenCalledWith(

expect.stringContaining("issue: provider catalog entry read failed"),

"Doctor warnings",

);

});

it("skips doctor config writes under legacy update parents", () => {

expect(

shouldSkipLegacyUpdateDoctorConfigWrite({

}

}

function formatRuntimeToolSchemaFindings(findings: readonly HealthFinding[]): string {

function formatHealthFindings(findings: readonly HealthFinding[]): string {

return findings

.map((finding) => {

const lines = [`- ${finding.message}`];

.join("\n");

}

async function runProviderCatalogProjectionHealth(ctx: DoctorHealthFlowContext): Promise<void> {

const { registerCoreHealthChecks } = await loadDoctorCoreChecksModule();

const { getHealthCheck } = await loadHealthCheckRegistryModule();

const { resolveAgentWorkspaceDir, resolveDefaultAgentId } = await loadAgentScopeModule();

const { note } = await loadNoteModule();

registerCoreHealthChecks();

const check = getHealthCheck("core/doctor/provider-catalog-projection");

if (!check) {

return;

}

const findings = await check.detect({

mode: "doctor",

runtime: ctx.runtime,

cfg: ctx.cfg,

cwd: resolveAgentWorkspaceDir(ctx.cfg, resolveDefaultAgentId(ctx.cfg)),

configPath: ctx.configPath,

});

if (findings.length === 0) {

return;

}

ctx.healthOk = false;

note(formatHealthFindings(findings), "Doctor warnings");

}

async function runRuntimeToolSchemasHealth(ctx: DoctorHealthFlowContext): Promise<void> {

const { registerCoreHealthChecks } = await loadDoctorCoreChecksModule();

const { getHealthCheck } = await loadHealthCheckRegistryModule();

return;

}

ctx.healthOk = false;

note(formatRuntimeToolSchemaFindings(findings), "Doctor warnings");

note(formatHealthFindings(findings), "Doctor warnings");

}

export function resolveDoctorHealthContributions(): DoctorHealthContribution[] {

label: "Tool result cap",

run: runToolResultCapHealth,

}),

createDoctorHealthContribution({

id: "doctor:provider-catalog-projection",

label: "Provider catalog projection",

healthCheckIds: ["core/doctor/provider-catalog-projection"],

run: runProviderCatalogProjectionHealth,

}),

createDoctorHealthContribution({

id: "doctor:runtime-tool-schemas",

label: "Runtime tool schemas",

target: ["core/doctor/tool-result-cap"],

rule: "Detect explicit live tool-result cap overrides that are stale or ineffective; preserve deep-mode effective cap output as finding metadata.",

},

{

contributionId: "doctor:provider-catalog-projection",

conversion: "detect-only",

target: ["core/doctor/provider-catalog-projection"],

rule: "Validate provider catalog hooks against unified text catalog projection and report malformed plugin catalog rows during doctor.",

},

{

contributionId: "doctor:runtime-tool-schemas",

conversion: "detect-only",

? { [params.providerId]: params.result.provider }

: params.result.providers;

const rows: UnifiedModelCatalogEntry[] = [];

// Doctor owns malformed plugin catalog diagnostics; runtime projection stays on

// the typed provider catalog contract instead of carrying fallback semantics.

for (const [providerId, providerConfig] of Object.entries(providers)) {

for (const model of providerConfig.models ?? []) {

rows.push({