// Verifies configured model ref resolution and OpenRouter compatibility aliases.

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

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

import { resolveAllowedModelRef, resolveConfiguredModelRef } from "./model-selection-resolve.js";

describe("model-selection-resolve OpenRouter compat aliases", () => {

it("preserves exact configured proxy provider ids for cron-style aliases", () => {

// Proxy providers can intentionally own short ids like "cron"; keep the

// configured provider scope instead of treating the id as a global alias.

const cfg = {

agents: {

defaults: {

});

it("resolves openrouter:auto through the canonical OpenRouter auto model", () => {

// Colon syntax is a legacy operator shortcut for OpenRouter's auto route.

const cfg = {

agents: {

defaults: {

// Covers plugin-owned model id normalization through selection surfaces.

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

const normalizeProviderModelIdWithPluginMock = vi.fn();

});

it("keeps model visibility policy construction off plugin runtime hooks by default", async () => {

// Visibility policy is a hot/static path. It preserves configured keys

// unless callers explicitly opt into runtime plugin normalization.

normalizeProviderModelIdWithPluginMock.mockImplementation(({ provider, context }) => {

if (

provider === "custom-provider" &&

});

it("keeps plugin-normalized stored overrides allowed in auto-reply runtime selection", async () => {

// Stored session overrides are runtime inputs, so provider-owned

// normalization keeps old persisted ids usable without resetting them.

normalizeProviderModelIdWithPluginMock.mockImplementation(({ provider, context }) => {

if (

provider === "custom-provider" &&

// Exercises core model selection, aliases, thinking defaults, and visibility policy.

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

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

import { resetLogger, setLoggerOverride } from "../logging/logger.js";

];

function resolveAnthropicOpusThinking(cfg: OpenClawConfig) {

// Helper keeps thinking-default assertions focused on config differences

// while using the same catalog metadata shape as production selection.

return resolveThinkingDefault({

cfg,

provider: "anthropic",

fallbacks?: string[];

agentFallbacks?: string[];

}) {

// Compact fixture for primary/fallback allowlist tests.

return {

agents: {

defaults: {

// Documents model tool-support compatibility defaults.

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

import { supportsModelTools } from "./model-tool-support.js";

// Verifies models.json planning applies config env vars and discovery scope.

import fs from "node:fs/promises";

import os from "node:os";

import path from "node:path";

}

function createImplicitOpenAiProvider(overrides: Partial<ProviderConfig> = {}): ProviderConfig {

// Minimal implicit OpenAI provider used to verify write planning without live

// discovery or real credentials.

return {

baseUrl: "https://api.openai.com/v1",

api: "openai-responses",

cfg: OpenClawConfig;

onResolveImplicitProviders: (env: NodeJS.ProcessEnv) => void;

}) {

// Config env vars are materialized into the discovery env before implicit

// provider resolution.

const env = createConfigRuntimeEnv(params.cfg);

return await resolveProvidersForModelsJsonWithDeps(

{

let unauthenticatedProviderParsed: { providers?: Record<string, unknown> };

beforeAll(async () => {

// Reused no-auth write plan proves generated providers stay serializable

// even when discovery returns auth-only provider shells.

unauthenticatedProviderWritePlan = await planOpenClawModelsJsonWithDeps(

{

cfg: { models: { providers: {} } },

// Verifies models.json writes and repairs use private file permissions.

import fs from "node:fs/promises";

import path from "node:path";

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

});

it("repairs models.json mode to 0600 on no-content-change paths", async () => {

// No-op content updates should still harden existing file permissions.

if (process.platform === "win32") {

return;

}