@drakon-systems/multi-clawd 1.0.0

package/dist/index.js

@@ -0,0 +1,508 @@
+import { definePluginEntry } from "openclaw/plugin-sdk/plugin-entry";
+import { resolvePluginConfigObject, resolveLivePluginConfigObject, } from "openclaw/plugin-sdk/plugin-config-runtime";
+import { CLI_FRESH_WATCHDOG_DEFAULTS, CLI_RESUME_WATCHDOG_DEFAULTS, } from "openclaw/plugin-sdk/cli-backend";
+import { homedir } from "node:os";
+import { mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { MODEL_ALIASES, buildCatalogEntries, canonicalModelId, isModernClaudeModelId, resolveModelSpec, } from "./models.js";
+import { decideDegradation, matchesPin } from "./degrade.js";
+import { resolveExecMode, permissionModeArgs } from "./exec-policy.js";
+import { resolveBaseModelIds } from "./catalog-source.js";
+import { classifyAccountHealth } from "./health.js";
+import { decideStickySelection } from "./sticky.js";
+import { createTokenRefResolver, isSecretRefShape, } from "./token-resolution.js";
+import { resolveSecretRefValues } from "openclaw/plugin-sdk/secret-ref-runtime";
+import { addAlert, clearAlert, pendingAlertText } from "./alerts.js";
+import { buildAccountChildEnv, validateAccountTokenSources } from "./account-env.js";
+import { checkAccountCredential, createRefProbeTracker, } from "./login-health.js";
+import { execFileSync } from "node:child_process";
+const BASE_ARGS = [
+    "-p",
+    "--output-format",
+    "stream-json",
+    "--include-partial-messages",
+    "--verbose",
+    "--setting-sources",
+    "user",
+    "--allowedTools",
+    "mcp__openclaw__*",
+    "--disallowedTools",
+    "ScheduleWakeup,CronCreate,Bash(run_in_background:true),Monitor",
+];
+const CLEAR_ENV = [
+    "ANTHROPIC_API_KEY",
+    "ANTHROPIC_API_KEY_OLD",
+    "ANTHROPIC_API_TOKEN",
+    "ANTHROPIC_AUTH_TOKEN",
+    "ANTHROPIC_BASE_URL",
+    "ANTHROPIC_CUSTOM_HEADERS",
+    "ANTHROPIC_OAUTH_TOKEN",
+    "ANTHROPIC_UNIX_SOCKET",
+    "CLAUDE_CONFIG_DIR",
+    "CLAUDE_CODE_API_KEY_FILE_DESCRIPTOR",
+    "CLAUDE_CODE_ENTRYPOINT",
+    "CLAUDE_CODE_OAUTH_REFRESH_TOKEN",
+    "CLAUDE_CODE_OAUTH_SCOPES",
+    "CLAUDE_CODE_OAUTH_TOKEN",
+    "CLAUDE_CODE_OAUTH_TOKEN_FILE_DESCRIPTOR",
+    "CLAUDE_CODE_PLUGIN_CACHE_DIR",
+    "CLAUDE_CODE_PLUGIN_SEED_DIR",
+    "CLAUDE_CODE_REMOTE",
+    "CLAUDE_CODE_USE_COWORK_PLUGINS",
+    "CLAUDE_CODE_USE_BEDROCK",
+    "CLAUDE_CODE_USE_FOUNDRY",
+    "CLAUDE_CODE_USE_VERTEX",
+];
+function expandHome(p) {
+    if (p === "~")
+        return homedir();
+    if (p.startsWith("~/"))
+        return resolve(homedir(), p.slice(2));
+    return resolve(p);
+}
+let activeTokenResolver;
+let alertState = { alerts: [] };
+let loginProbeTimer;
+function raiseAlert(alert) {
+    alertState = addAlert(alertState, alert, Date.now());
+}
+function ingestAlertSpool() {
+    const spool = join(homedir(), ".openclaw", "state", "multi-clawd", "alerts-spool.jsonl");
+    let raw;
+    try {
+        raw = readFileSync(spool, "utf8");
+    }
+    catch {
+        return;
+    }
+    try {
+        for (const line of raw.split("\n")) {
+            if (!line.trim())
+                continue;
+            try {
+                const alert = JSON.parse(line);
+                if (typeof alert.key === "string" && typeof alert.text === "string") {
+                    alertState = addAlert(alertState, {
+                        key: alert.key,
+                        severity: alert.severity === "error" ? "error" : "info",
+                        text: alert.text,
+                    }, alert.at ?? Date.now());
+                }
+            }
+            catch {
+            }
+        }
+        rmSync(spool, { force: true });
+    }
+    catch {
+    }
+}
+const LOGIN_PROBE_INTERVAL_MS = 15 * 60 * 1000;
+const LOGIN_PROBE_INITIAL_DELAY_MS = 45 * 1000;
+const realCredentialIo = {
+    readFile: (p) => readFileSync(expandHome(p), "utf8"),
+    keychainHasClaudeCredentials: () => {
+        try {
+            execFileSync("security", ["find-generic-password", "-s", "Claude Code-credentials"], {
+                stdio: "ignore",
+            });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    },
+    platform: process.platform,
+};
+function startLoginHealthProbe(accounts, logger) {
+    if (loginProbeTimer)
+        clearInterval(loginProbeTimer);
+    const lastStatus = new Map();
+    const refTrackers = new Map();
+    const probe = async () => {
+        const now = Date.now();
+        for (const account of accounts) {
+            let status;
+            let reason;
+            if (isSecretRefShape(account.oauthTokenRef) && !account.oauthTokenFile && !account.native) {
+                let tracker = refTrackers.get(account.id);
+                if (!tracker) {
+                    tracker = createRefProbeTracker();
+                    refTrackers.set(account.id, tracker);
+                }
+                const result = (await activeTokenResolver?.resolveDetailed(account.oauthTokenRef)) ?? {
+                    failure: "provider_error",
+                };
+                const outcome = tracker.observe(result, now);
+                status = outcome.status;
+                reason = outcome.reason;
+            }
+            else {
+                const check = checkAccountCredential(account, realCredentialIo);
+                status = check.status;
+                reason = check.reason;
+            }
+            const previous = lastStatus.get(account.id);
+            lastStatus.set(account.id, status);
+            if (status === "broken" && previous !== "broken") {
+                const text = `account "${account.id}" login looks dead (${reason ?? "unknown"}) — turns on it will fail until fixed`;
+                logger.error(`[multi-clawd] ${text}`);
+                raiseAlert({ key: `login:${account.id}`, severity: "error", text });
+            }
+            else if (status === "degraded" && previous !== "degraded") {
+                logger.info(`[multi-clawd] account "${account.id}" login degraded: ${reason ?? "resolver error"}`);
+            }
+            else if (status === "ok" && (previous === "broken" || previous === "degraded")) {
+                logger.info(`[multi-clawd] account "${account.id}" login recovered`);
+                alertState = clearAlert(alertState, `login:${account.id}`);
+            }
+        }
+    };
+    const initial = setTimeout(() => void probe().catch(() => { }), LOGIN_PROBE_INITIAL_DELAY_MS);
+    initial.unref?.();
+    loginProbeTimer = setInterval(() => void probe().catch(() => { }), LOGIN_PROBE_INTERVAL_MS);
+    loginProbeTimer.unref?.();
+}
+function peekToken(account) {
+    if (account.native)
+        return undefined;
+    if (account.oauthTokenFile) {
+        return readFileSync(expandHome(account.oauthTokenFile), "utf8").trim();
+    }
+    if (isSecretRefShape(account.oauthTokenRef)) {
+        return activeTokenResolver?.peek(account.oauthTokenRef);
+    }
+    if (account.configDir)
+        return undefined;
+    throw new Error(`[multi-clawd] account "${account.id}" needs oauthTokenFile, oauthTokenRef, or configDir`);
+}
+async function resolveTokenAsync(account) {
+    if (isSecretRefShape(account.oauthTokenRef) && !account.native && !account.oauthTokenFile) {
+        return activeTokenResolver?.resolve(account.oauthTokenRef);
+    }
+    return peekToken(account);
+}
+function buildRuntimeModel(account, modelId) {
+    const id = canonicalModelId(modelId);
+    if (!id)
+        return undefined;
+    const label = account.label ?? account.id;
+    const spec = resolveModelSpec(id);
+    return {
+        id,
+        name: `${spec.name} (${label})`,
+        provider: account.id,
+        api: "anthropic-messages",
+        baseUrl: "https://api.anthropic.com",
+        reasoning: true,
+        input: ["text", "image"],
+        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+        contextWindow: spec.contextWindow,
+        maxTokens: spec.maxTokens,
+        ...(id === "claude-fable-5" || id === "claude-mythos-5"
+            ? { thinkingLevelMap: { xhigh: "xhigh", max: "max" } }
+            : {}),
+        mediaInput: {
+            image: {
+                maxSidePx: spec.imageMaxSidePx,
+                preferredSidePx: spec.imageMaxSidePx,
+                tokenMode: "provider",
+            },
+        },
+    };
+}
+const SHIM_PATH = fileURLToPath(new URL("./shim.js", import.meta.url));
+export function healthStateFile(accountId) {
+    return join(homedir(), ".openclaw", "state", "multi-clawd", `${accountId}.json`);
+}
+function buildBackend(account, execMode) {
+    return {
+        id: account.id,
+        liveTest: {
+            defaultModelRef: `${account.id}/${account.defaultModel ?? "claude-fable-5"}`,
+            defaultImageProbe: true,
+            defaultMcpProbe: true,
+            docker: {
+                npmPackage: "@anthropic-ai/claude-code",
+                binaryName: "claude",
+            },
+        },
+        bundleMcp: true,
+        bundleMcpMode: "claude-config-file",
+        nativeToolMode: "always-on",
+        sideQuestionToolMode: "disabled",
+        ownsNativeCompaction: true,
+        config: {
+            command: process.execPath,
+            args: [SHIM_PATH, ...BASE_ARGS, ...permissionModeArgs(execMode)],
+            resumeArgs: [SHIM_PATH, ...BASE_ARGS, ...permissionModeArgs(execMode), "--resume", "{sessionId}"],
+            output: "jsonl",
+            liveSession: "claude-stdio",
+            input: "stdin",
+            jsonlDialect: "claude-stream-json",
+            modelArg: "--model",
+            modelAliases: { ...MODEL_ALIASES },
+            imageArg: "@",
+            imagePathScope: "workspace",
+            sessionArg: "--session-id",
+            sessionMode: "always",
+            reseedFromRawTranscriptWhenUncompacted: false,
+            sessionIdFields: ["session_id", "sessionId", "conversation_id", "conversationId"],
+            systemPromptFileArg: "--append-system-prompt-file",
+            systemPromptMode: "append",
+            systemPromptWhen: "always",
+            clearEnv: [...CLEAR_ENV],
+            reliability: {
+                watchdog: {
+                    fresh: { ...CLI_FRESH_WATCHDOG_DEFAULTS },
+                    resume: { ...CLI_RESUME_WATCHDOG_DEFAULTS },
+                },
+            },
+            serialize: true,
+        },
+        async prepareExecution(_ctx) {
+            return { env: await buildAccountEnv(account) };
+        },
+    };
+}
+async function buildAccountEnv(account) {
+    const token = await resolveTokenAsync(account);
+    return buildAccountChildEnv(account, token, healthStateFile(account.id));
+}
+function buildCatalogProvider(account) {
+    return {
+        id: account.id,
+        label: account.label ?? `Claude Code (${account.id})`,
+        auth: [],
+        resolveSyntheticAuth: () => {
+            try {
+                const token = peekToken(account);
+                if (!token)
+                    return undefined;
+                return {
+                    apiKey: token,
+                    source: `multi-clawd ${account.id} token`,
+                    mode: "token",
+                };
+            }
+            catch {
+                return undefined;
+            }
+        },
+        augmentModelCatalog: async () => buildCatalogEntries(account, await resolveBaseModelIds()),
+        resolveDynamicModel: (ctx) => buildRuntimeModel(account, ctx.modelId),
+    };
+}
+export default definePluginEntry({
+    id: "multi-clawd",
+    name: "multi-clawd",
+    description: "Register additional Claude Code logins as first-class OpenClaw CLI backends for cross-account failover.",
+    register(api) {
+        const runtimeConfigLoader = (api.runtime?.config?.current
+            ? () => api.runtime.config.current()
+            : undefined);
+        const candidates = [
+            resolveLivePluginConfigObject(runtimeConfigLoader, "multi-clawd", api.pluginConfig),
+            resolvePluginConfigObject(api.config, "multi-clawd"),
+            api.pluginConfig,
+        ];
+        const hasAccounts = (c) => Array.isArray(c?.accounts) &&
+            (c.accounts?.length ?? 0) > 0;
+        const cfg = (candidates.find(hasAccounts) ?? {});
+        const accounts = Array.isArray(cfg.accounts) ? cfg.accounts : [];
+        const sourceNames = [
+            "runtime-live",
+            "static-api-config",
+            "startup-pluginConfig",
+        ];
+        if (accounts.length === 0) {
+            api.logger.warn(`[multi-clawd] no accounts configured — nothing to register (sources: ${candidates
+                .map((c, i) => `${sourceNames[i]}=${hasAccounts(c) ? "ok" : c ? "empty" : "absent"}`)
+                .join(", ")})`);
+            return;
+        }
+        api.logger.info(`[multi-clawd] register() pass — config source: ${sourceNames[candidates.findIndex(hasAccounts)] ?? "unknown"}, accounts: ${accounts.length}`);
+        {
+            const logger = api.logger;
+            const currentConfig = api.runtime?.config?.current;
+            activeTokenResolver = createTokenRefResolver({
+                resolveRefs: (refs) => resolveSecretRefValues(refs, {
+                    config: (currentConfig ? currentConfig() : api.config),
+                }),
+                redact: true,
+                onError: (_ref, error) => logger.error(`[multi-clawd] ${String(error)}`),
+            });
+        }
+        const execMode = resolveExecMode(runtimeConfigLoader?.() ?? api.config);
+        api.logger.info(`[multi-clawd] exec policy: ${execMode ?? "unknown"} → permission-mode ${permissionModeArgs(execMode).length ? "bypassPermissions" : "default (no override)"}`);
+        const seen = new Set();
+        for (const account of accounts) {
+            const id = account?.id?.trim();
+            if (!id) {
+                api.logger.warn("[multi-clawd] skipping account without id");
+                continue;
+            }
+            for (const warning of validateAccountTokenSources(account)) {
+                api.logger.warn(`[multi-clawd] ${warning}`);
+            }
+            if (id === "claude-cli" || seen.has(id)) {
+                api.logger.warn(`[multi-clawd] skipping account "${id}" — id collides with an existing backend`);
+                continue;
+            }
+            seen.add(id);
+            const normalized = { ...account, id };
+            api.registerCliBackend(buildBackend(normalized, execMode));
+            api.registerProvider(buildCatalogProvider(normalized));
+        }
+        registerPoolBackend(api, cfg.pool, accounts, seen, execMode);
+        {
+            const logger = api.logger;
+            try {
+                api.on("heartbeat_prompt_contribution", () => {
+                    ingestAlertSpool();
+                    const text = pendingAlertText(alertState, Date.now());
+                    return text ? { appendContext: text } : undefined;
+                });
+            }
+            catch (err) {
+                logger.warn(`[multi-clawd] heartbeat alert hook unavailable: ${String(err)}`);
+            }
+            startLoginHealthProbe(accounts.filter((a) => seen.has(a.id.trim())), logger);
+        }
+        api.logger.info(`[multi-clawd] registered ${seen.size} backend(s)+provider(s): ${[...seen].join(", ")}`);
+    },
+});
+function readHealthState(accountId) {
+    try {
+        return JSON.parse(readFileSync(healthStateFile(accountId), "utf8"));
+    }
+    catch {
+        return undefined;
+    }
+}
+function readStickyEntry(file) {
+    try {
+        const parsed = JSON.parse(readFileSync(file, "utf8"));
+        if (typeof parsed?.account === "string" && typeof parsed?.since === "number") {
+            return parsed;
+        }
+    }
+    catch {
+    }
+    return undefined;
+}
+function writeStickyEntry(file, entry, logger) {
+    try {
+        if (!entry) {
+            rmSync(file, { force: true });
+            return;
+        }
+        mkdirSync(dirname(file), { recursive: true });
+        const tmp = `${file}.tmp-${process.pid}`;
+        writeFileSync(tmp, JSON.stringify(entry), { mode: 0o600 });
+        renameSync(tmp, file);
+    }
+    catch (err) {
+        logger.warn(`[multi-clawd] sticky state write failed: ${String(err)}`);
+    }
+}
+function registerPoolBackend(api, pool, accounts, registeredIds, execMode) {
+    const logger = api.logger;
+    if (!pool)
+        return;
+    const poolId = pool.id?.trim() || "clawd";
+    const memberIds = (pool.accounts ?? []).filter((id) => registeredIds.has(id));
+    const members = memberIds
+        .map((id) => accounts.find((a) => a.id.trim() === id))
+        .filter((a) => a !== undefined);
+    const ladder = (pool.degrade?.ladder ?? []).filter((m) => {
+        if (isModernClaudeModelId(m))
+            return true;
+        logger.warn(`[multi-clawd] pool "${poolId}": ignoring invalid degrade ladder entry "${m}"`);
+        return false;
+    });
+    const pins = pool.degrade?.pins ?? [];
+    if (members.length < 2 && !(members.length === 1 && ladder.length > 0)) {
+        logger.warn(`[multi-clawd] pool "${poolId}" has ${members.length} registered account(s) — need at least 2 (or 1 with a degrade ladder); pool not registered`);
+        return;
+    }
+    if (poolId === "claude-cli" || registeredIds.has(poolId)) {
+        logger.warn(`[multi-clawd] pool id "${poolId}" collides with an existing backend — pool not registered`);
+        return;
+    }
+    const options = {
+        utilizationThreshold: pool.utilizationThreshold,
+        staleAfterMs: pool.staleAfterMs,
+    };
+    const poolAccount = {
+        id: poolId,
+        label: pool.label ?? `Claude pool (${memberIds.join("+")})`,
+        models: pool.models,
+        defaultModel: pool.defaultModel,
+    };
+    const minDwellMs = pool.minDwellMs;
+    const stickyFile = join(homedir(), ".openclaw", "state", "multi-clawd", `pool-${poolId}.sticky.json`);
+    const backend = buildBackend(poolAccount, execMode);
+    backend.prepareExecution = async (ctx) => {
+        const now = Date.now();
+        const requestedModel = canonicalModelId(ctx.modelId) ?? ctx.modelId;
+        const verdicts = members.map((a) => ({
+            id: a.id,
+            health: classifyAccountHealth(readHealthState(a.id), options, now, requestedModel),
+        }));
+        const previousSticky = readStickyEntry(stickyFile);
+        const decision = decideStickySelection({
+            verdicts: verdicts.map((v) => ({ id: v.id, verdict: v.health.verdict })),
+            sticky: previousSticky,
+            nowMs: now,
+            minDwellMs,
+        });
+        const chosen = members.find((a) => a.id === decision.account) ?? members[0];
+        const previousAccount = previousSticky?.account ?? members[0].id;
+        if (decision.account !== previousAccount) {
+            const home = verdicts[0];
+            const line = decision.account === members[0].id
+                ? `pool ${poolId}: returning home to ${decision.account}`
+                : `pool ${poolId}: rotated to ${decision.account} from ${previousAccount} (${home.health.reason ?? home.health.verdict})`;
+            logger.info(`[multi-clawd] ${line}`);
+            raiseAlert({ key: `rotation:${poolId}`, severity: "info", text: line });
+        }
+        if (verdicts.every((v) => v.health.verdict === "exhausted")) {
+            raiseAlert({
+                key: `pool-exhausted:${poolId}:${requestedModel}`,
+                severity: "error",
+                text: `pool ${poolId}: every account is exhausted for ${requestedModel} — turns are degrading or falling through the chain`,
+            });
+        }
+        writeStickyEntry(stickyFile, decision.sticky, logger);
+        const env = await buildAccountEnv(chosen);
+        if (ladder.length > 0) {
+            const pinned = matchesPin(pins, {
+                agentDir: ctx.agentDir ?? "",
+                workspaceDir: ctx.workspaceDir,
+            });
+            const degradation = pinned
+                ? undefined
+                : decideDegradation({
+                    verdicts: verdicts.map((v) => ({ id: v.id, verdict: v.health.verdict })),
+                    requestedModel: ctx.modelId,
+                    ladder,
+                });
+            if (degradation) {
+                env.MULTI_CLAWD_MODEL_OVERRIDE = degradation.model;
+                const line = `pool ${poolId}: degrading ${ctx.modelId} → ${degradation.model} on ${chosen.id} (${degradation.reason})`;
+                logger.info(`[multi-clawd] ${line}`);
+                raiseAlert({ key: `degrade:${poolId}`, severity: "info", text: line });
+            }
+            else if (pinned && verdicts.every((v) => v.health.verdict === "exhausted")) {
+                logger.info(`[multi-clawd] pool ${poolId}: pinned lane keeps ${ctx.modelId} despite exhausted pool (will fail over via the chain)`);
+            }
+        }
+        return { env };
+    };
+    api.registerCliBackend(backend);
+    api.registerProvider(buildCatalogProvider(poolAccount));
+    registeredIds.add(poolId);
+    logger.info(`[multi-clawd] pool "${poolId}" active — accounts: ${memberIds.join(" → ")}, threshold: ${options.utilizationThreshold ?? 0.85}`);
+}

package/dist/login-health.js

@@ -0,0 +1,91 @@
+export function createRefProbeTracker(options = {}) {
+    const deadAfterConsecutive = options.deadAfterConsecutive ?? 3;
+    const deadAfterMs = options.deadAfterMs ?? 10 * 60 * 1000;
+    let consecutive = 0;
+    let firstFailureAt;
+    return {
+        observe(result, nowMs) {
+            if (result.value !== undefined) {
+                consecutive = 0;
+                firstFailureAt = undefined;
+                return { status: "ok" };
+            }
+            if (result.failure === "empty_result") {
+                consecutive = 0;
+                firstFailureAt = undefined;
+                return {
+                    status: "broken",
+                    reason: "oauthTokenRef resolved to nothing (credential problem)",
+                };
+            }
+            if (consecutive === 0)
+                firstFailureAt = nowMs;
+            consecutive += 1;
+            const elapsed = nowMs - (firstFailureAt ?? nowMs);
+            if (consecutive >= deadAfterConsecutive && elapsed >= deadAfterMs) {
+                return {
+                    status: "broken",
+                    reason: `resolver failing ${deadAfterConsecutive}+ consecutive probes over ${Math.round(deadAfterMs / 60000)}m`,
+                };
+            }
+            return {
+                status: "degraded",
+                reason: `resolver error (network?) — streak ${consecutive}/${deadAfterConsecutive}`,
+            };
+        },
+    };
+}
+function looksLikeSetupToken(value) {
+    return /^sk-ant-[a-z0-9]+-/.test(value.trim());
+}
+function checkCredentialsJson(io, dir) {
+    let raw;
+    try {
+        raw = io.readFile(`${dir}/.credentials.json`);
+    }
+    catch {
+        return { status: "broken", reason: `${dir}/.credentials.json unreadable` };
+    }
+    try {
+        const parsed = JSON.parse(raw);
+        const token = parsed?.claudeAiOauth?.accessToken;
+        if (typeof token === "string" && token.trim().length > 0)
+            return { status: "ok" };
+        return { status: "broken", reason: `${dir}/.credentials.json access token is blank` };
+    }
+    catch {
+        return { status: "broken", reason: `${dir}/.credentials.json is not valid JSON` };
+    }
+}
+export function checkAccountCredential(account, io) {
+    if (account.oauthTokenFile) {
+        let raw;
+        try {
+            raw = io.readFile(account.oauthTokenFile);
+        }
+        catch {
+            return { status: "broken", reason: `${account.oauthTokenFile} unreadable` };
+        }
+        if (looksLikeSetupToken(raw))
+            return { status: "ok" };
+        return {
+            status: "broken",
+            reason: `${account.oauthTokenFile} does not contain a setup-token`,
+        };
+    }
+    if (account.oauthTokenRef) {
+        return { status: "unknown" };
+    }
+    if (account.native) {
+        if (io.platform === "darwin") {
+            return io.keychainHasClaudeCredentials()
+                ? { status: "ok" }
+                : { status: "broken", reason: "keychain has no Claude Code credentials" };
+        }
+        return checkCredentialsJson(io, "~/.claude");
+    }
+    if (account.configDir) {
+        return checkCredentialsJson(io, account.configDir);
+    }
+    return { status: "unknown" };
+}

package/dist/models.js

@@ -0,0 +1,69 @@
+export const MODEL_ALIASES = {
+    opus: "opus",
+    "opus-4.8": "claude-opus-4-8",
+    "opus-4.7": "claude-opus-4-7",
+    "opus-4.6": "claude-opus-4-6",
+    sonnet: "sonnet",
+    "sonnet-4.6": "claude-sonnet-4-6",
+    haiku: "haiku",
+};
+const KNOWN_SPECS = {
+    "claude-opus-4-8": { name: "Claude Opus 4.8", contextWindow: 1048576, maxTokens: 128000 },
+    "claude-opus-4-7": { name: "Claude Opus 4.7", contextWindow: 1048576, maxTokens: 64000 },
+    "claude-opus-4-6": { name: "Claude Opus 4.6", contextWindow: 1048576, maxTokens: 64000 },
+    "claude-sonnet-4-6": { name: "Claude Sonnet 4.6", contextWindow: 1048576, maxTokens: 64000 },
+    "claude-sonnet-5": { name: "Claude Sonnet 5", contextWindow: 200000, maxTokens: 64000 },
+    "claude-fable-5": { name: "Claude Fable 5", contextWindow: 1000000, maxTokens: 128000 },
+    "claude-haiku-4-5": { name: "Claude Haiku 4.5", contextWindow: 200000, maxTokens: 64000 },
+};
+export const FALLBACK_MODEL_IDS = Object.keys(KNOWN_SPECS);
+const MODERN_CLAUDE_ID_RE = /^claude(-[a-z0-9]+(\.[a-z0-9]+)*)+$/;
+export function isModernClaudeModelId(id) {
+    return MODERN_CLAUDE_ID_RE.test(id);
+}
+const CLI_SHORT_ALIASES = new Set(["opus", "sonnet", "haiku"]);
+export function canonicalModelId(modelId) {
+    const trimmed = modelId?.trim();
+    if (!trimmed)
+        return undefined;
+    const aliased = MODEL_ALIASES[trimmed] ?? trimmed;
+    if (CLI_SHORT_ALIASES.has(aliased))
+        return aliased;
+    return isModernClaudeModelId(aliased) ? aliased : undefined;
+}
+function deriveName(id) {
+    return id
+        .split("-")
+        .map((part) => (/^[a-z]/.test(part) ? part[0].toUpperCase() + part.slice(1) : part))
+        .join(" ")
+        .replace(/^Claude (\w+) (\d+) (\d)$/, "Claude $1 $2.$3");
+}
+export function resolveModelSpec(id) {
+    const known = KNOWN_SPECS[id];
+    const imageMaxSidePx = id === "claude-opus-4-8" || id === "claude-opus-4-7" ? 2576 : 1568;
+    if (known)
+        return { ...known, imageMaxSidePx };
+    return { name: deriveName(id), contextWindow: 200000, maxTokens: 64000, imageMaxSidePx };
+}
+export function buildCatalogEntries(account, baseIds) {
+    const label = account.label ?? account.id;
+    const ids = [...new Set([...baseIds, ...(account.models ?? [])])].filter(isModernClaudeModelId);
+    return ids.map((id) => {
+        const spec = resolveModelSpec(id);
+        return {
+            id,
+            name: `${spec.name} (${label})`,
+            provider: account.id,
+            reasoning: true,
+            input: ["text", "image"],
+            contextWindow: spec.contextWindow,
+            mediaInput: {
+                image: {
+                    maxSidePx: spec.imageMaxSidePx,
+                    preferredSidePx: spec.imageMaxSidePx,
+                    tokenMode: "provider",
+                },
+            },
+        };
+    });
+}