type ProviderAuthResult,

} from "openclaw/plugin-sdk/provider-auth";

import { normalizeLowercaseStringOrEmpty } from "openclaw/plugin-sdk/string-coerce-runtime";

import { resolveClaudeCliAnthropicModelRefs } from "./claude-model-refs.js";

import {

readClaudeCliCredentialsForSetup,

readClaudeCliCredentialsForSetupNonInteractive,

type ClaudeCliCredential = NonNullable<ReturnType<typeof readClaudeCliCredentialsForSetup>>;

function toAnthropicModelRef(raw: string): string | null {

const trimmed = raw.trim();

const lower = normalizeLowercaseStringOrEmpty(trimmed);

const provider = lower.startsWith("anthropic/")

? "anthropic"

: lower.startsWith(`${CLAUDE_CLI_BACKEND_ID}/`)

? CLAUDE_CLI_BACKEND_ID

: "";

if (!provider) {

return null;

}

const modelId = trimmed.slice(provider.length + 1).trim();

if (!normalizeLowercaseStringOrEmpty(modelId).startsWith("claude-")) {

return null;

}

return `anthropic/${modelId}`;

return resolveClaudeCliAnthropicModelRefs(raw)?.rewriteRef ?? null;

}

function toAnthropicRuntimeRefs(raw: string): string[] {

return resolveClaudeCliAnthropicModelRefs(raw)?.runtimeRefs ?? [];

}

function toAnthropicSelectedModelRef(raw: string): string | undefined {

const resolved = resolveClaudeCliAnthropicModelRefs(raw);

return resolved?.rewriteRef ?? resolved?.selectedRef;

}

function isRecord(value: unknown): value is Record<string, unknown> {

changed: boolean;

} {

if (typeof model === "string") {

const runtimeRefs = toAnthropicRuntimeRefs(model);

const converted = toAnthropicModelRef(model);

const selectedRef = converted ?? toAnthropicSelectedModelRef(model);

return converted

? { value: converted, primary: converted, runtimeRefs: [converted], changed: true }

: { value: model, runtimeRefs: [], changed: false };

? { value: converted, primary: converted, runtimeRefs, changed: true }

: {

value: model,

...(selectedRef ? { primary: selectedRef } : {}),

runtimeRefs,

changed: false,

};

}

if (!model || typeof model !== "object" || Array.isArray(model)) {

return { value: model, runtimeRefs: [], changed: false };

let primary: string | undefined;

if (typeof current.primary === "string") {

runtimeRefs.push(...toAnthropicRuntimeRefs(current.primary));

const converted = toAnthropicModelRef(current.primary);

if (converted) {

next.primary = converted;

primary = converted;

runtimeRefs.push(converted);

changed = true;

} else {

primary = toAnthropicSelectedModelRef(current.primary);

}

}

if (typeof entry !== "string") {

return entry;

}

runtimeRefs.push(...toAnthropicRuntimeRefs(entry));

const converted = toAnthropicModelRef(entry);

if (converted) {

runtimeRefs.push(converted);

}

return converted ?? entry;

});

if (nextFallbacks.some((entry, index) => entry !== currentFallbacks[index])) {

function rewriteModelEntryMap(models: Record<string, unknown> | undefined): {

value: Record<string, unknown> | undefined;

migrated: string[];

runtimeRefs: string[];

} {

if (!models) {

return { value: models, migrated: [] };

return { value: models, migrated: [], runtimeRefs: [] };

}

const next = { ...models };

const migrated: string[] = [];

const runtimeRefs: string[] = [];

for (const [rawKey, value] of Object.entries(models)) {

runtimeRefs.push(...toAnthropicRuntimeRefs(rawKey));

const converted = toAnthropicModelRef(rawKey);

if (!converted) {

continue;

if (!(converted in next)) {

next[converted] = value;

}

delete next[rawKey];

if (normalizeLowercaseStringOrEmpty(rawKey).startsWith(`${CLAUDE_CLI_BACKEND_ID}/`)) {

delete next[rawKey];

}

migrated.push(converted);

}

return {

value: migrated.length > 0 ? next : models,

value: migrated.length > 0 || runtimeRefs.length > 0 ? next : models,

migrated,

runtimeRefs,

};

}

{}) as NonNullable<AgentDefaultsModels>;

const nextModels = seedClaudeCliAllowlist(existingModels, [

...rewrittenModel.runtimeRefs,

...rewrittenModels.runtimeRefs,

...rewrittenModels.migrated,

]);

const defaultModel = rewrittenModel.primary ?? "anthropic/claude-opus-4-7";