/** Auth availability index for `openclaw models list` rows. */

import { normalizeProviderIdForAuth } from "@openclaw/model-catalog-core/provider-id";

import type { AuthProfileStore } from "../../agents/auth-profiles/types.js";

import type { AuthProfileCredential } from "../../agents/auth-profiles/types.js";

allowsProviderAuthAvailabilityFallback(provider: string): boolean;

};

/** Inputs used to build the auth index without re-reading process-wide state. */

export type CreateModelListAuthIndexParams = {

cfg: OpenClawConfig;

authStore: AuthProfileStore;

.flatMap((plugin) => plugin.syntheticAuthRefs ?? []);

}

/** Builds a provider-auth lookup from profiles, env, config, and synthetic plugin refs. */

export function createModelListAuthIndex(

params: CreateModelListAuthIndexParams,

): ModelListAuthIndex {

if (credential.type !== "oauth" && credential.type !== "token") {

return false;

}

// OpenAI OAuth/token profiles only authenticate provider rows when config

// routes OpenAI through Codex runtime semantics.

return openAIProviderUsesCodexRuntimeByDefault({

provider: normalizedProvider,

config: params.cfg,

params.cfg.agents?.defaults?.model,

)?.split("/", 1)[0];

if (primaryModelProvider === "codex") {

// A Codex primary model is a synthetic provider auth signal even when no

// normal provider key exists in the profile store.

addSyntheticProvider("codex");

}

/** Builds provider auth summaries for model-list/status output. */

import { normalizeProviderIdForAuth } from "@openclaw/model-catalog-core/provider-id";

import {

normalizeLowercaseStringOrEmpty,

: params.agentDir;

}

/** Resolves the effective auth source and profile counts for a provider. */

export function resolveProviderAuthOverview(params: {

provider: string;

cfg: OpenClawConfig;

const effective: ProviderAuthOverview["effective"] = (() => {

if (profiles.length > 0) {

// Profiles win over env/config markers because runtime auth selection uses

// the profile store before provider-wide fallback material.

return {

kind: "profiles",

detail: shortenHomePath(

/** Resolves configured model refs and tags for model-list rows. */

import {

buildModelAliasIndex,

resolveConfiguredModelRef,

const DISPLAY_MODEL_PARSE_OPTIONS = { allowPluginNormalization: false } as const;

/** Returns canonical configured model entries with default/fallback/image/configured tags. */

export function resolveConfiguredEntries(

cfg: OpenClawConfig,

metadataSnapshot?: Pick<PluginMetadataSnapshot, "manifestRegistry">,

const key = modelKey(canonicalRef.provider, canonicalRef.model);

const originalKey = modelKey(ref.provider, ref.model);

if (originalKey !== key) {

// Preserve aliases attached to pre-canonical provider keys so display rows

// still show user-facing aliases after catalog provider canonicalization.

const aliases = aliasesByKey.get(originalKey);

if (aliases) {

aliasesByKey.set(key, [...new Set([...(aliasesByKey.get(key) ?? []), ...aliases])]);

// Shared error helpers for model-list availability fallback behavior.

/** Error code used when model availability lookup is unavailable but auth heuristics can continue. */

export const MODEL_AVAILABILITY_UNAVAILABLE_CODE = "MODEL_AVAILABILITY_UNAVAILABLE";

/** Formats an unknown error with stack detail when available. */

export function formatErrorWithStack(err: unknown): string {

if (err instanceof Error) {

return err.stack ?? `${err.name}: ${err.message}`;

}

return String(err);

}

/** Returns true when model list should continue with auth heuristics. */

export function shouldFallbackToAuthHeuristics(err: unknown): boolean {

if (!(err instanceof Error)) {

return false;

/** Formatting helpers for model-list terminal tables. */

import { isRich as isRichTerminal, theme } from "../../../packages/terminal-core/src/theme.js";

export { maskApiKey } from "../../utils/mask-api-key.js";

/** Enables rich formatting only for non-machine-readable output. */

export const isRich = (opts?: { json?: boolean; plain?: boolean }) =>

isRichTerminal() && !opts?.json && !opts?.plain;

/** Pads a table cell to a fixed width. */

export const pad = (value: string, size: number) => value.padEnd(size);

/** Applies terminal color based on a model-list tag. */

export const formatTag = (tag: string, rich: boolean) => {

if (!rich) {

return tag;

return theme.muted(tag);

};

/** Truncates model-list cells with an ASCII ellipsis. */

export const truncate = (value: string, max: number) => {

if (value.length <= max) {

return value;

/** Implementation of `openclaw models list`. */

import { normalizeLowercaseStringOrEmpty } from "@openclaw/normalization-core/string-coerce";

import { parseModelRef } from "../../agents/model-selection.js";

import type { ModelRegistry } from "../../llm/model-registry.js";

return sourcePlanModuleLoader.load();

}

/** Lists configured, catalog, and runtime-discovered models as text, plain, or JSON. */

export async function modelsListCommand(

opts: {

all?: boolean;

const { entries } = resolveConfiguredEntries(cfg, metadataSnapshot);

const configuredByKey = new Map(entries.map((entry) => [entry.key, entry]));

const enableSourcePlanCascade = Boolean(opts.all) || Boolean(providerFilter);

// Full/provider-filtered lists may need runtime, manifest, and registry rows.

// Defer that planning so default configured-only output stays cheap.

const sourcePlanModule = enableSourcePlanCascade ? await loadSourcePlanModule() : undefined;

const sourcePlan = sourcePlanModule

? await sourcePlanModule.planAllModelListSources({

});

if (initialAppend.requiresRegistryFallback) {

const useScopedRegistryFallback = sourcePlan.kind === "provider-runtime-scoped";

// Runtime-scoped providers can fail catalog availability while still being

// useful for a provider-filtered list; retry through the registry fallback.

try {

await loadRegistryState(

useScopedRegistryFallback

/** Local URL classifier for model provider status/list output. */

import { normalizeLowercaseStringOrEmpty } from "@openclaw/normalization-core/string-coerce";

/** Returns true for loopback, wildcard, and mDNS local base URLs. */

export const isLocalBaseUrl = (baseUrl: string) => {

try {

const url = new URL(baseUrl);

/** Manifest-backed model catalog row loaders for `openclaw models list`. */

import { normalizeModelCatalogProviderId } from "@openclaw/model-catalog-core/model-catalog-refs";

import type { NormalizedModelCatalogRow } from "@openclaw/model-catalog-core/model-catalog-types";

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

});

}

/** Loads authoritative static manifest catalog rows for model-list output. */

export function loadStaticManifestCatalogRowsForList(params: {

cfg: OpenClawConfig;

providerFilter?: string;

});

}

/** Loads supplemental non-runtime manifest catalog rows for fallback list sources. */

export function loadSupplementalManifestCatalogRowsForList(params: {

cfg: OpenClawConfig;

providerFilter?: string;