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

import { createModelPickerVisibleProviderPredicate } from "./model-picker-visibility.js";

import {

areRuntimeModelRefsEquivalent,

isCliRuntimeProvider,

resolveCliRuntimeExecutionProvider,

} from "./model-runtime-aliases.js";

expect(isVisibleProvider("acme-cli")).toBe(true);

});

});

describe("areRuntimeModelRefsEquivalent", () => {

afterEach(() => {

cliBackendsTesting.resetDepsForTest();

});

it("does not load setup runtime aliases for already-identical refs", () => {

cliBackendsTesting.setDepsForTest({

resolvePluginSetupRegistry: () => {

throw new Error("setup registry should not load for identical refs");

},

resolveRuntimeCliBackends: () => [],

});

expect(

areRuntimeModelRefsEquivalent("anthropic/claude", "anthropic/claude", {

config: {},

}),

).toBe(true);

});

});

return model ? `${canonicalProvider}/${model}` : canonicalProvider;

}

function normalizeRuntimeModelRefWithoutAlias(raw: string): string {

const trimmed = raw.trim();

const slash = trimmed.indexOf("/");

if (slash <= 0 || slash >= trimmed.length - 1) {

return normalizeProviderId(trimmed);

}

const provider = trimmed.slice(0, slash).trim();

const model = trimmed.slice(slash + 1).trim();

const normalizedProvider = normalizeProviderId(provider);

return model ? `${normalizedProvider}/${model}` : normalizedProvider;

}

export function areRuntimeModelRefsEquivalent(

left: string,

right: string,

options: RuntimeAliasComparisonOptions = {},

): boolean {

if (normalizeRuntimeModelRefWithoutAlias(left) === normalizeRuntimeModelRefWithoutAlias(right)) {

return true;

}

return (

normalizeRuntimeModelRefForComparison(left, options) ===

normalizeRuntimeModelRefForComparison(right, options)

runOverrides: { sessionId: "stale-session" },

sessionStore,

});

state.runEmbeddedAgentMock.mockResolvedValueOnce({

payloads: [{ text: "final" }],

meta: {

agentMeta: {

provider: "anthropic",

model: "claude",

usage: { input: 1, output: 1 },

},

},

});

const pending = run();

await new Promise<void>((resolve) => setTimeout(resolve, 0));