openclaw/src/plugins/provider-discovery.runtime.test.ts

import { beforeEach, describe, expect, it, vi } from "vitest";
import type { PluginManifestRecord } from "./manifest-registry.js";
import type { ProviderPlugin } from "./types.js";

const mocks = vi.hoisted(() => ({
  loadPluginMetadataSnapshot: vi.fn(),
  resolvePluginMetadataSnapshot: vi.fn(),
  resolveDiscoveredProviderPluginIds: vi.fn(),
  resolvePluginProviders: vi.fn(),
  loadSource: vi.fn(),
}));

vi.mock("./plugin-metadata-snapshot.js", async (importOriginal) => {
  const actual = await importOriginal<typeof import("./plugin-metadata-snapshot.js")>();
  return {
    ...actual,
    loadPluginMetadataSnapshot: mocks.loadPluginMetadataSnapshot,
    resolvePluginMetadataSnapshot: mocks.resolvePluginMetadataSnapshot,
  };
});

vi.mock("./providers.js", () => ({
  resolveDiscoveredProviderPluginIds: mocks.resolveDiscoveredProviderPluginIds,
}));

vi.mock("./providers.runtime.js", () => ({
  resolvePluginProviders: mocks.resolvePluginProviders,
}));

vi.mock("./source-loader.js", () => ({
  createPluginSourceLoader: () => mocks.loadSource,
}));

import { resolvePluginDiscoveryProvidersRuntime } from "./provider-discovery.runtime.js";

function createManifestPlugin(id: string): PluginManifestRecord {
  return {
    id,
    enabledByDefault: true,
    channels: [],
    providers: [id],
    cliBackends: [],
    skills: [],
    hooks: [],
    origin: "bundled",
    rootDir: `/tmp/${id}`,
    source: "bundled",
    manifestPath: `/tmp/${id}/openclaw.plugin.json`,
    providerDiscoverySource: `/tmp/${id}/provider-discovery.ts`,
  };
}

function createManifestPluginWithModelCatalog(id: string): PluginManifestRecord {
  return {
    ...createManifestPluginWithoutDiscovery({ id }),
    modelCatalog: {
      providers: {
        [id]: {
          baseUrl: "https://catalog.example.test/v1",
          api: "openai-responses",
          models: [
            {
              id: "catalog-model",
              name: "Catalog Model",
              reasoning: true,
              input: ["text"],
              contextWindow: 128000,
              maxTokens: 4096,
              cost: { input: 1, output: 2, cacheRead: 0.1, cacheWrite: 0 },
            },
          ],
        },
      },
      discovery: { [id]: "static" },
    },
  };
}

function createManifestPluginWithoutDiscovery(params: {
  id: string;
  providerAuthEnvVars?: Record<string, string[]>;
  setupProviders?: NonNullable<PluginManifestRecord["setup"]>["providers"];
}): PluginManifestRecord {
  const { providerDiscoverySource: _providerDiscoverySource, ...plugin } = createManifestPlugin(
    params.id,
  );
  return {
    ...plugin,
    ...(params.setupProviders ? { setup: { providers: params.setupProviders } } : {}),
    ...(params.providerAuthEnvVars ? { providerAuthEnvVars: params.providerAuthEnvVars } : {}),
  };
}

function createProvider(params: { id: string; mode: "static" | "catalog" }): ProviderPlugin {
  const hook = {
    run: async () => ({
      provider: {
        baseUrl: "https://example.test/v1",
        models: [],
      },
    }),
  };
  return {
    id: params.id,
    label: params.id,
    auth: [],
    ...(params.mode === "static" ? { staticCatalog: hook } : { catalog: hook }),
  };
}

function requireResolvePluginProvidersParams(index = 0): {
  onlyPluginIds?: string[];
} {
  const params = (mocks.resolvePluginProviders.mock.calls[index] as [unknown] | undefined)?.[0] as
    | {
        onlyPluginIds?: string[];
      }
    | undefined;
  if (!params) {
    throw new Error(`resolvePluginProviders call ${index} missing`);
  }
  return params;
}

function requireDiscoveredProviderIdsParams(index = 0): {
  registry?: unknown;
  manifestRegistry?: unknown;
} {
  const params = (
    mocks.resolveDiscoveredProviderPluginIds.mock.calls[index] as [unknown] | undefined
  )?.[0] as
    | {
        registry?: unknown;
        manifestRegistry?: unknown;
      }
    | undefined;
  if (!params) {
    throw new Error(`resolveDiscoveredProviderPluginIds call ${index} missing`);
  }
  return params;
}

describe("resolvePluginDiscoveryProvidersRuntime", () => {
  beforeEach(() => {
    vi.clearAllMocks();
    mocks.resolveDiscoveredProviderPluginIds.mockReturnValue(["deepseek"]);
    mocks.loadPluginMetadataSnapshot.mockReturnValue({
      index: { plugins: [] },
      manifestRegistry: {
        plugins: [createManifestPlugin("deepseek")],
        diagnostics: [],
      },
    });
    mocks.resolvePluginMetadataSnapshot.mockImplementation(
      (params?: { pluginMetadataSnapshot?: unknown }) =>
        params?.pluginMetadataSnapshot ?? mocks.loadPluginMetadataSnapshot(params),
    );
  });

  it("uses static provider catalog entries without loading the full plugin", () => {
    const staticProvider = createProvider({ id: "deepseek", mode: "static" });
    mocks.loadSource.mockReturnValue(staticProvider);

    expect(resolvePluginDiscoveryProvidersRuntime({})).toEqual([
      { ...staticProvider, pluginId: "deepseek" },
    ]);
    expect(mocks.resolvePluginProviders).not.toHaveBeenCalled();
  });

  it("keeps unscoped discovery bounded for mixed live and static-only entries", () => {
    const codexEntryProvider = createProvider({ id: "codex", mode: "catalog" });
    const deepseekEntryProvider = createProvider({ id: "deepseek", mode: "static" });
    const fullProviders = [createProvider({ id: "kilocode", mode: "catalog" })];
    mocks.resolveDiscoveredProviderPluginIds.mockReturnValue([
      "codex",
      "deepseek",
      "kilocode",
      "unused",
    ]);
    mocks.loadPluginMetadataSnapshot.mockReturnValue({
      index: { plugins: [] },
      manifestRegistry: {
        plugins: [
          createManifestPlugin("codex"),
          createManifestPlugin("deepseek"),
          createManifestPluginWithoutDiscovery({
            id: "kilocode",
            providerAuthEnvVars: { kilocode: ["KILOCODE_API_KEY"] },
          }),
          createManifestPluginWithoutDiscovery({
            id: "unused",
            providerAuthEnvVars: { unused: ["UNUSED_API_KEY"] },
          }),
        ],
        diagnostics: [],
      },
    });
    mocks.loadSource.mockImplementation((modulePath: string) =>
      modulePath.includes("/codex/") ? codexEntryProvider : deepseekEntryProvider,
    );
    mocks.resolvePluginProviders.mockReturnValue(fullProviders);

    expect(
      resolvePluginDiscoveryProvidersRuntime({
        env: { KILOCODE_API_KEY: "sk-test" } as NodeJS.ProcessEnv,
      }),
    ).toEqual([
      { ...codexEntryProvider, pluginId: "codex" },
      { ...deepseekEntryProvider, pluginId: "deepseek" },
      ...fullProviders,
    ]);
    expect(mocks.resolvePluginProviders).toHaveBeenCalledTimes(1);
    const params = requireResolvePluginProvidersParams();
    expect(params.onlyPluginIds).toEqual(["kilocode"]);
  });

  it("falls back to full provider plugins when setup provider env vars are configured", () => {
    const codexEntryProvider = createProvider({ id: "codex", mode: "catalog" });
    const fullProviders = [createProvider({ id: "kilocode", mode: "catalog" })];
    mocks.resolveDiscoveredProviderPluginIds.mockReturnValue(["codex", "kilocode"]);
    mocks.loadPluginMetadataSnapshot.mockReturnValue({
      index: { plugins: [] },
      manifestRegistry: {
        plugins: [
          createManifestPlugin("codex"),
          createManifestPluginWithoutDiscovery({
            id: "kilocode",
            setupProviders: [{ id: "kilocode", envVars: ["KILOCODE_API_KEY"] }],
          }),
        ],
        diagnostics: [],
      },
    });
    mocks.loadSource.mockReturnValue(codexEntryProvider);
    mocks.resolvePluginProviders.mockReturnValue(fullProviders);

    expect(
      resolvePluginDiscoveryProvidersRuntime({
        env: { KILOCODE_API_KEY: "sk-test" } as NodeJS.ProcessEnv,
      }),
    ).toEqual([{ ...codexEntryProvider, pluginId: "codex" }, ...fullProviders]);
    expect(mocks.resolvePluginProviders).toHaveBeenCalledTimes(1);
    const params = requireResolvePluginProvidersParams();
    expect(params.onlyPluginIds).toEqual(["kilocode"]);
  });

  it("shares one metadata snapshot between provider id discovery and entry loading", () => {
    const registry = { plugins: [] };
    const manifestRegistry = {
      plugins: [createManifestPlugin("deepseek")],
      diagnostics: [],
    };
    mocks.loadPluginMetadataSnapshot.mockReturnValue({
      index: registry,
      manifestRegistry,
    });
    mocks.loadSource.mockReturnValue(createProvider({ id: "deepseek", mode: "catalog" }));

    resolvePluginDiscoveryProvidersRuntime({ config: {}, env: {} as NodeJS.ProcessEnv });

    expect(mocks.loadPluginMetadataSnapshot).toHaveBeenCalledWith(
      expect.objectContaining({
        config: {},
        env: {},
      }),
    );
    expect(mocks.loadPluginMetadataSnapshot).toHaveBeenCalledOnce();
    expect(mocks.resolveDiscoveredProviderPluginIds).toHaveBeenCalledTimes(1);
    const params = requireDiscoveredProviderIdsParams();
    expect(params.registry).toBe(registry);
    expect(params.manifestRegistry).toBe(manifestRegistry);
  });

  it("uses a provided plugin metadata snapshot without rebuilding registry metadata", () => {
    const registry = { plugins: [] };
    const manifestRegistry = {
      plugins: [createManifestPlugin("deepseek")],
      diagnostics: [],
    };
    mocks.loadSource.mockReturnValue(createProvider({ id: "deepseek", mode: "catalog" }));

    const providers = resolvePluginDiscoveryProvidersRuntime({
      config: {},
      env: {} as NodeJS.ProcessEnv,
      pluginMetadataSnapshot: {
        index: registry as never,
        manifestRegistry,
      },
    });
    expect(providers).toHaveLength(1);
    expect(providers[0]?.id).toBe("deepseek");
    expect(providers[0]?.pluginId).toBe("deepseek");

    expect(mocks.loadPluginMetadataSnapshot).not.toHaveBeenCalled();
    expect(mocks.resolveDiscoveredProviderPluginIds).toHaveBeenCalledTimes(1);
    const params = requireDiscoveredProviderIdsParams();
    expect(params.registry).toBe(registry);
    expect(params.manifestRegistry).toBe(manifestRegistry);
  });

  it("returns static-only discovery entries for callers that explicitly request them", () => {
    const staticProvider = createProvider({ id: "deepseek", mode: "static" });
    mocks.loadSource.mockReturnValue(staticProvider);

    const providers = resolvePluginDiscoveryProvidersRuntime({ discoveryEntriesOnly: true });
    expect(providers).toHaveLength(1);
    expect(providers[0]?.id).toBe("deepseek");
    expect(providers[0]?.pluginId).toBe("deepseek");
    expect(providers[0]?.staticCatalog).toBe(staticProvider.staticCatalog);
    expect(mocks.resolvePluginProviders).not.toHaveBeenCalled();
  });

  it("returns manifest model catalogs as static discovery entries", async () => {
    mocks.resolveDiscoveredProviderPluginIds.mockReturnValue(["openai"]);
    mocks.loadPluginMetadataSnapshot.mockReturnValue({
      index: { plugins: [] },
      manifestRegistry: {
        plugins: [createManifestPluginWithModelCatalog("openai")],
        diagnostics: [],
      },
    });

    const providers = resolvePluginDiscoveryProvidersRuntime({ discoveryEntriesOnly: true });

    expect(providers.map((provider) => provider.id)).toEqual(["openai"]);
    expect(providers[0]?.pluginId).toBe("openai");
    expect(mocks.resolvePluginProviders).not.toHaveBeenCalled();
    await expect(
      providers[0]?.staticCatalog?.run({
        config: {},
        env: {},
        resolveProviderApiKey: () => ({ apiKey: undefined }),
        resolveProviderAuth: () => ({ apiKey: undefined, mode: "none", source: "none" }),
      }),
    ).resolves.toEqual({
      providers: {
        openai: {
          baseUrl: "https://catalog.example.test/v1",
          api: "openai-responses",
          models: [
            expect.objectContaining({
              id: "catalog-model",
              name: "Catalog Model",
              reasoning: true,
            }),
          ],
        },
      },
    });
  });

  it("defaults missing manifest model costs for static discovery entries", async () => {
    mocks.resolveDiscoveredProviderPluginIds.mockReturnValue(["anthropic"]);
    mocks.loadPluginMetadataSnapshot.mockReturnValue({
      index: { plugins: [] },
      manifestRegistry: {
        plugins: [
          {
            ...createManifestPluginWithModelCatalog("anthropic"),
            modelCatalog: {
              providers: {
                anthropic: {
                  baseUrl: "https://api.anthropic.com",
                  api: "anthropic-messages",
                  models: [
                    {
                      id: "claude-sonnet-4-6",
                      name: "Claude Sonnet 4.6",
                      reasoning: true,
                      input: ["text"],
                      contextWindow: 200000,
                      maxTokens: 64000,
                    },
                  ],
                },
              },
              discovery: { anthropic: "static" },
            },
          },
        ],
        diagnostics: [],
      },
    });

    const providers = resolvePluginDiscoveryProvidersRuntime({ discoveryEntriesOnly: true });

    await expect(
      providers[0]?.staticCatalog?.run({
        config: {},
        env: {},
        resolveProviderApiKey: () => ({ apiKey: undefined }),
        resolveProviderAuth: () => ({ apiKey: undefined, mode: "none", source: "none" }),
      }),
    ).resolves.toEqual({
      providers: {
        anthropic: expect.objectContaining({
          models: [
            expect.objectContaining({
              id: "claude-sonnet-4-6",
              cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
            }),
          ],
        }),
      },
    });
  });

  it("ignores manifest model catalogs that cannot form valid models.json providers", () => {
    mocks.resolveDiscoveredProviderPluginIds.mockReturnValue(["anthropic"]);
    mocks.loadPluginMetadataSnapshot.mockReturnValue({
      index: { plugins: [] },
      manifestRegistry: {
        plugins: [
          {
            ...createManifestPluginWithModelCatalog("anthropic"),
            modelCatalog: {
              providers: {
                "claude-cli": {
                  models: [
                    {
                      id: "claude-sonnet-4-6",
                      name: "Claude Sonnet 4.6",
                      reasoning: true,
                      input: ["text"],
                      contextWindow: 200000,
                      maxTokens: 64000,
                    },
                  ],
                },
                anthropic: {
                  baseUrl: "https://api.anthropic.com",
                  api: "anthropic-messages",
                  models: [
                    {
                      id: "claude-sonnet-4-6",
                      name: "Claude Sonnet 4.6",
                      reasoning: true,
                      input: ["text"],
                      contextWindow: 200000,
                      maxTokens: 64000,
                    },
                  ],
                },
              },
              discovery: { "claude-cli": "static", anthropic: "static" },
            },
          },
        ],
        diagnostics: [],
      },
    });

    const providers = resolvePluginDiscoveryProvidersRuntime({ discoveryEntriesOnly: true });

    expect(providers.map((provider) => provider.id)).toEqual(["anthropic"]);
  });

  it("keeps manifest catalogs and loads only scoped plugins that have no entry", () => {
    const dynamicProvider = createProvider({ id: "minimax", mode: "catalog" });
    mocks.resolveDiscoveredProviderPluginIds.mockReturnValue(["minimax", "openai"]);
    mocks.loadPluginMetadataSnapshot.mockReturnValue({
      index: { plugins: [] },
      manifestRegistry: {
        plugins: [
          createManifestPluginWithoutDiscovery({ id: "minimax" }),
          createManifestPluginWithModelCatalog("openai"),
        ],
        diagnostics: [],
      },
    });
    mocks.resolvePluginProviders.mockReturnValue([dynamicProvider]);

    const providers = resolvePluginDiscoveryProvidersRuntime({
      onlyPluginIds: ["minimax", "openai"],
    });

    expect(providers.map((provider) => provider.id)).toEqual(["openai", "minimax"]);
    expect(mocks.resolvePluginProviders).toHaveBeenCalledTimes(1);
    expect(requireResolvePluginProvidersParams().onlyPluginIds).toEqual(["minimax"]);
  });

  it("does not fall back to full plugin loading when discovery entries are requested only", () => {
    mocks.loadPluginMetadataSnapshot.mockReturnValue({
      index: { plugins: [] },
      manifestRegistry: {
        plugins: [createManifestPluginWithoutDiscovery({ id: "deepseek" })],
        diagnostics: [],
      },
    });

    expect(resolvePluginDiscoveryProvidersRuntime({ discoveryEntriesOnly: true })).toStrictEqual(
      [],
    );
    expect(resolvePluginDiscoveryProvidersRuntime({ discoveryEntriesOnly: true })).toStrictEqual(
      [],
    );
    expect(mocks.resolvePluginProviders).not.toHaveBeenCalled();
  });
});