// Verifies CLI runtime alias resolution and runtime model-ref equivalence.

import { afterEach, beforeEach, describe, expect, it } from "vitest";

import type { OpenClawConfig } from "../config/types.openclaw.js";

import { testing as cliBackendsTesting } from "./cli-backends.js";

order?: string[];

models?: NonNullable<NonNullable<OpenClawConfig["agents"]>["defaults"]>["models"];

}): OpenClawConfig {

// Auth order controls whether Anthropic execution is direct API or Claude

// CLI-backed when no explicit runtime policy overrides it.

return {

auth: {

order: params.order ? { anthropic: params.order } : undefined,

});

it("does not override an explicit OpenClaw model-runtime policy with CLI auth", () => {

// Runtime policy is more explicit than profile order, so CLI auth cannot

// force a model onto the CLI harness when config says OpenClaw.

expect(

resolveCliRuntimeExecutionProvider({

cfg: createAnthropicAuthConfig({

});

it("resolves one setup runtime alias without loading the full setup registry", () => {

// Equivalence checks use targeted setup lookup so hot model comparisons do

// not load the full plugin setup registry.

cliBackendsTesting.setDepsForTest({

resolvePluginSetupCliBackend: ({ backend }) =>

backend === "claude-cli"

// Covers model runtime policy precedence and private QA runtime overrides.

import { afterEach, describe, expect, it } from "vitest";

import type { ModelDefinitionConfig } from "../config/types.models.js";

import type { OpenClawConfig } from "../config/types.openclaw.js";

name: "OPENCLAW_BUILD_PRIVATE_QA" | "OPENCLAW_QA_FORCE_RUNTIME",

value: string | undefined,

): void {

// Tests mutate private QA env gates; restore exact process state after each.

if (value == null) {

delete process.env[name];

return;

});

it("respects the QA force-runtime override when the private QA gate is set", () => {

// The force-runtime override is intentionally gated to private QA builds so

// normal users cannot accidentally change model runtime selection via env.

process.env.OPENCLAW_BUILD_PRIVATE_QA = "1";

process.env.OPENCLAW_QA_FORCE_RUNTIME = "openclaw";

});

it("prefers exact agent model runtime policy entries over provider wildcards", () => {

// Exact configured model refs beat provider wildcards to keep intentional

// per-model runtime routing stable.

const config = {

agents: {

defaults: {

// Verifies OpenRouter model scan filtering, metadata normalization, and timeouts.

import { MAX_TIMER_TIMEOUT_MS } from "@openclaw/normalization-core/number-coercion";

import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";

import { withEnvAsync } from "../test-utils/env.js";

import { withFetchPreconnect } from "../test-utils/fetch-mock.js";

import { scanOpenRouterModels } from "./model-scan.js";

function createFetchFixture(payload: unknown): typeof fetch {

// scanOpenRouterModels accepts an injected fetch so tests stay offline while

// exercising OpenRouter's catalog response shape.

return withFetchPreconnect(

async () =>

new Response(JSON.stringify(payload), {

});

it("caps oversized scan timeouts before scheduling catalog aborts", async () => {

// Timer APIs cannot safely schedule above the platform max; cap before

// creating the catalog abort timeout.

const timeoutSpy = vi

.spyOn(globalThis, "setTimeout")

.mockReturnValue(1 as unknown as ReturnType<typeof setTimeout>);

});

it("does not match provider filters across provider id variants", async () => {

// Provider filters are literal OpenRouter owner ids. Do not normalize z.ai

// into z-ai here or scans will include unintended rows.

const fetchImpl = createFetchFixture({

data: [

{

// Verifies model-selection CLI provider detection from plugin metadata.

import { afterEach, beforeEach, describe, expect, it } from "vitest";

import type { OpenClawConfig } from "../config/types.js";

import {

import { isCliProvider } from "./model-selection-cli.js";

function setCliBackendMetadataSnapshot(cliBackends: string[]) {

// Builds a minimal current plugin metadata snapshot so isCliProvider can use

// descriptor metadata without loading setup runtime modules.

const policyHash = resolveInstalledPluginIndexPolicyHash({});

const index: InstalledPluginIndex = {

version: 1,

});

it("does not execute setup runtime when descriptor metadata has no matching backend", () => {

// Negative checks should stay metadata-only; loading setup runtime here

// would make simple provider visibility queries expensive.

setupRegistryRuntimeTesting.setRuntimeModuleForTest({

resolvePluginSetupCliBackend: () => {

throw new Error("setup runtime should not load for CLI provider checks");

// Documents persisted/runtime model selection display normalization.

import { describe, expect, it } from "vitest";

import {

resolveModelDisplayName,

});

it("ignores malformed persisted model values instead of throwing", () => {

// Session files can contain old or malformed values; display helpers

// should fall back to safe refs rather than breaking status output.

expect(

resolveModelDisplayRef({

runtimeProvider: { provider: "openai" },

});

it("keeps override ids attached to the current provider when no override provider is stored", () => {

// Slash-bearing override models may be nested model ids, not providers;

// preserve the known current provider when no override provider exists.

expect(

resolveSessionInfoModelSelection({

currentProvider: "anthropic",

// Verifies configured model selection uses manifest policy only in scoped contexts.

import { beforeEach, describe, expect, it, vi } from "vitest";

import type { OpenClawConfig } from "../config/types.openclaw.js";

});

it("does not reuse workspace manifest policies without a workspace context", async () => {

// Workspace plugin normalization must not leak into unscoped callers; they

// can only use the current global metadata snapshot.

const { buildConfiguredModelCatalog } = await import("./model-selection-shared.js");

const cfg = {

models: {

});

it("does not load manifest metadata for empty configured model aliases", async () => {

// Alias indexing is a hot config path. Empty inputs should avoid manifest

// scans entirely.

const { buildModelAliasIndex } = await import("./model-selection-shared.js");

const cfg = {} as unknown as OpenClawConfig;