@poolzin/pool-bot 2026.2.17 → 2026.2.19

package/dist/commands/doctor.e2e-harness.js

@@ -0,0 +1,364 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { afterEach, beforeEach, vi } from "vitest";
+let originalIsTTY;
+let originalStateDir;
+let originalUpdateInProgress;
+let tempStateDir;
+function setStdinTty(value) {
+    try {
+        Object.defineProperty(process.stdin, "isTTY", {
+            value,
+            configurable: true,
+        });
+    }
+    catch {
+        // ignore
+    }
+}
+function createGatewayUpdateResult() {
+    return {
+        status: "skipped",
+        mode: "unknown",
+        steps: [],
+        durationMs: 0,
+    };
+}
+function createCommandWithTimeoutResult() {
+    return {
+        stdout: "",
+        stderr: "",
+        code: 0,
+        signal: null,
+        killed: false,
+    };
+}
+function createLegacyConfigSnapshot() {
+    return {
+        path: "/tmp/poolbot.json",
+        exists: false,
+        raw: null,
+        parsed: {},
+        valid: true,
+        config: {},
+        issues: [],
+        legacyIssues: [],
+    };
+}
+export const readConfigFileSnapshot = vi.fn();
+export const confirm = vi.fn().mockResolvedValue(true);
+export const select = vi.fn().mockResolvedValue("node");
+export const note = vi.fn();
+export const writeConfigFile = vi.fn().mockResolvedValue(undefined);
+export const resolveOpenClawPackageRoot = vi.fn().mockResolvedValue(null);
+export const runGatewayUpdate = vi
+    .fn()
+    .mockResolvedValue(createGatewayUpdateResult());
+export const migrateLegacyConfig = vi.fn((raw) => ({
+    config: raw,
+    changes: ["Moved routing.allowFrom → channels.whatsapp.allowFrom."],
+}));
+export const runExec = vi.fn().mockResolvedValue({
+    stdout: "",
+    stderr: "",
+});
+export const runCommandWithTimeout = vi
+    .fn()
+    .mockResolvedValue(createCommandWithTimeoutResult());
+export const ensureAuthProfileStore = vi
+    .fn()
+    .mockReturnValue({ version: 1, profiles: {} });
+export const legacyReadConfigFileSnapshot = vi
+    .fn()
+    .mockResolvedValue(createLegacyConfigSnapshot());
+export const createConfigIO = vi.fn(() => ({
+    readConfigFileSnapshot: legacyReadConfigFileSnapshot,
+}));
+export const findLegacyGatewayServices = vi.fn().mockResolvedValue([]);
+export const uninstallLegacyGatewayServices = vi.fn().mockResolvedValue([]);
+export const findExtraGatewayServices = vi.fn().mockResolvedValue([]);
+export const renderGatewayServiceCleanupHints = vi
+    .fn()
+    .mockReturnValue(["cleanup"]);
+export const resolveGatewayProgramArguments = vi.fn().mockResolvedValue({
+    programArguments: ["node", "cli", "gateway", "--port", "18789"],
+});
+export const serviceInstall = vi.fn().mockResolvedValue(undefined);
+export const serviceIsLoaded = vi.fn().mockResolvedValue(false);
+export const serviceStop = vi.fn().mockResolvedValue(undefined);
+export const serviceRestart = vi.fn().mockResolvedValue(undefined);
+export const serviceUninstall = vi.fn().mockResolvedValue(undefined);
+export const callGateway = vi
+    .fn()
+    .mockRejectedValue(new Error("gateway closed"));
+export const autoMigrateLegacyStateDir = vi.fn().mockResolvedValue({
+    migrated: false,
+    skipped: false,
+    changes: [],
+    warnings: [],
+});
+function createLegacyStateMigrationDetectionResult(params) {
+    return {
+        targetAgentId: "main",
+        targetMainKey: "main",
+        targetScope: undefined,
+        stateDir: "/tmp/state",
+        oauthDir: "/tmp/oauth",
+        sessions: {
+            legacyDir: "/tmp/state/sessions",
+            legacyStorePath: "/tmp/state/sessions/sessions.json",
+            targetDir: "/tmp/state/agents/main/sessions",
+            targetStorePath: "/tmp/state/agents/main/sessions/sessions.json",
+            hasLegacy: params?.hasLegacySessions ?? false,
+            legacyKeys: [],
+        },
+        agentDir: {
+            legacyDir: "/tmp/state/agent",
+            targetDir: "/tmp/state/agents/main/agent",
+            hasLegacy: false,
+        },
+        whatsappAuth: {
+            legacyDir: "/tmp/oauth",
+            targetDir: "/tmp/oauth/whatsapp/default",
+            hasLegacy: false,
+        },
+        pairingAllowFrom: {
+            legacyTelegramPath: "/tmp/oauth/telegram-allowFrom.json",
+            targetTelegramPath: "/tmp/oauth/telegram-default-allowFrom.json",
+            hasLegacyTelegram: false,
+        },
+        preview: params?.preview ?? [],
+    };
+}
+export const detectLegacyStateMigrations = vi
+    .fn()
+    .mockResolvedValue(createLegacyStateMigrationDetectionResult());
+export const runLegacyStateMigrations = vi.fn().mockResolvedValue({
+    changes: [],
+    warnings: [],
+});
+const DEFAULT_CONFIG_SNAPSHOT = {
+    path: "/tmp/poolbot.json",
+    exists: true,
+    raw: "{}",
+    parsed: {},
+    valid: true,
+    config: {},
+    issues: [],
+    legacyIssues: [],
+};
+vi.mock("@clack/prompts", () => ({
+    confirm,
+    intro: vi.fn(),
+    note,
+    outro: vi.fn(),
+    select,
+}));
+vi.mock("../agents/skills-status.js", () => ({
+    buildWorkspaceSkillStatus: () => ({ skills: [] }),
+}));
+vi.mock("../plugins/loader.js", () => ({
+    loadPoolBotPlugins: () => ({ plugins: [], diagnostics: [] }),
+}));
+vi.mock("../config/config.js", async (importOriginal) => {
+    const actual = await importOriginal();
+    return {
+        ...actual,
+        CONFIG_PATH: "/tmp/poolbot.json",
+        createConfigIO,
+        readConfigFileSnapshot,
+        writeConfigFile,
+        migrateLegacyConfig,
+    };
+});
+vi.mock("../daemon/legacy.js", () => ({
+    findLegacyGatewayServices,
+    uninstallLegacyGatewayServices,
+}));
+vi.mock("../daemon/inspect.js", () => ({
+    findExtraGatewayServices,
+    renderGatewayServiceCleanupHints,
+}));
+vi.mock("../daemon/program-args.js", () => ({
+    resolveGatewayProgramArguments,
+}));
+vi.mock("../gateway/call.js", async (importOriginal) => {
+    const actual = await importOriginal();
+    return {
+        ...actual,
+        callGateway,
+    };
+});
+vi.mock("../process/exec.js", () => ({
+    runExec,
+    runCommandWithTimeout,
+}));
+vi.mock("../infra/openclaw-root.js", () => ({
+    resolveOpenClawPackageRoot,
+}));
+vi.mock("../infra/update-runner.js", () => ({
+    runGatewayUpdate,
+}));
+vi.mock("../agents/auth-profiles.js", async (importOriginal) => {
+    const actual = await importOriginal();
+    return {
+        ...actual,
+        ensureAuthProfileStore,
+    };
+});
+vi.mock("../daemon/service.js", () => ({
+    resolveGatewayService: () => ({
+        label: "LaunchAgent",
+        loadedText: "loaded",
+        notLoadedText: "not loaded",
+        install: serviceInstall,
+        uninstall: serviceUninstall,
+        stop: serviceStop,
+        restart: serviceRestart,
+        isLoaded: serviceIsLoaded,
+        readCommand: vi.fn(),
+        readRuntime: vi.fn().mockResolvedValue({ status: "running" }),
+    }),
+}));
+vi.mock("../pairing/pairing-store.js", () => ({
+    readChannelAllowFromStore: vi.fn().mockResolvedValue([]),
+    upsertChannelPairingRequest: vi.fn().mockResolvedValue({ code: "000000", created: false }),
+}));
+vi.mock("../telegram/token.js", () => ({
+    resolveTelegramToken: vi.fn(() => ({ token: "", source: "none" })),
+}));
+vi.mock("../runtime.js", () => ({
+    defaultRuntime: {
+        log: () => { },
+        error: () => { },
+        exit: () => {
+            throw new Error("exit");
+        },
+    },
+}));
+vi.mock("../utils.js", async (importOriginal) => {
+    const actual = await importOriginal();
+    return {
+        ...actual,
+        resolveUserPath: (value) => value,
+        sleep: vi.fn(),
+    };
+});
+vi.mock("./health.js", () => ({
+    healthCommand: vi.fn().mockResolvedValue(undefined),
+}));
+vi.mock("./onboard-helpers.js", () => ({
+    applyWizardMetadata: (cfg) => cfg,
+    DEFAULT_WORKSPACE: "/tmp",
+    guardCancel: (value) => value,
+    printWizardHeader: vi.fn(),
+    randomToken: vi.fn(() => "test-gateway-token"),
+}));
+vi.mock("./doctor-state-migrations.js", () => ({
+    autoMigrateLegacyStateDir,
+    detectLegacyStateMigrations,
+    runLegacyStateMigrations,
+}));
+export function mockDoctorConfigSnapshot(params = {}) {
+    readConfigFileSnapshot.mockResolvedValue({
+        ...DEFAULT_CONFIG_SNAPSHOT,
+        config: params.config ?? DEFAULT_CONFIG_SNAPSHOT.config,
+        parsed: params.parsed ?? DEFAULT_CONFIG_SNAPSHOT.parsed,
+        valid: params.valid ?? DEFAULT_CONFIG_SNAPSHOT.valid,
+        issues: params.issues ?? DEFAULT_CONFIG_SNAPSHOT.issues,
+        legacyIssues: params.legacyIssues ?? DEFAULT_CONFIG_SNAPSHOT.legacyIssues,
+    });
+}
+export function createDoctorRuntime() {
+    return {
+        log: vi.fn(),
+        error: vi.fn(),
+        exit: vi.fn(),
+    };
+}
+export async function arrangeLegacyStateMigrationTest() {
+    mockDoctorConfigSnapshot();
+    const { doctorCommand } = await import("./doctor.js");
+    const runtime = createDoctorRuntime();
+    detectLegacyStateMigrations.mockClear();
+    runLegacyStateMigrations.mockClear();
+    detectLegacyStateMigrations.mockResolvedValueOnce(createLegacyStateMigrationDetectionResult({
+        hasLegacySessions: true,
+        preview: ["- Legacy sessions detected"],
+    }));
+    runLegacyStateMigrations.mockResolvedValueOnce({
+        changes: ["migrated"],
+        warnings: [],
+    });
+    confirm.mockClear();
+    return {
+        doctorCommand,
+        runtime,
+        detectLegacyStateMigrations,
+        runLegacyStateMigrations,
+    };
+}
+beforeEach(() => {
+    confirm.mockReset().mockResolvedValue(true);
+    select.mockReset().mockResolvedValue("node");
+    note.mockClear();
+    readConfigFileSnapshot.mockReset();
+    writeConfigFile.mockReset().mockResolvedValue(undefined);
+    resolveOpenClawPackageRoot.mockReset().mockResolvedValue(null);
+    runGatewayUpdate.mockReset().mockResolvedValue(createGatewayUpdateResult());
+    legacyReadConfigFileSnapshot.mockReset().mockResolvedValue(createLegacyConfigSnapshot());
+    createConfigIO.mockReset().mockImplementation(() => ({
+        readConfigFileSnapshot: legacyReadConfigFileSnapshot,
+    }));
+    runExec.mockReset().mockResolvedValue({ stdout: "", stderr: "" });
+    runCommandWithTimeout.mockReset().mockResolvedValue(createCommandWithTimeoutResult());
+    ensureAuthProfileStore.mockReset().mockReturnValue({ version: 1, profiles: {} });
+    migrateLegacyConfig.mockReset().mockImplementation((raw) => ({
+        config: raw,
+        changes: ["Moved routing.allowFrom → channels.whatsapp.allowFrom."],
+    }));
+    findLegacyGatewayServices.mockReset().mockResolvedValue([]);
+    uninstallLegacyGatewayServices.mockReset().mockResolvedValue([]);
+    findExtraGatewayServices.mockReset().mockResolvedValue([]);
+    renderGatewayServiceCleanupHints.mockReset().mockReturnValue(["cleanup"]);
+    resolveGatewayProgramArguments.mockReset().mockResolvedValue({
+        programArguments: ["node", "cli", "gateway", "--port", "18789"],
+    });
+    serviceInstall.mockReset().mockResolvedValue(undefined);
+    serviceIsLoaded.mockReset().mockResolvedValue(false);
+    serviceStop.mockReset().mockResolvedValue(undefined);
+    serviceRestart.mockReset().mockResolvedValue(undefined);
+    serviceUninstall.mockReset().mockResolvedValue(undefined);
+    callGateway.mockReset().mockRejectedValue(new Error("gateway closed"));
+    originalIsTTY = process.stdin.isTTY;
+    setStdinTty(true);
+    originalStateDir = process.env.POOLBOT_STATE_DIR;
+    originalUpdateInProgress = process.env.POOLBOT_UPDATE_IN_PROGRESS;
+    process.env.POOLBOT_UPDATE_IN_PROGRESS = "1";
+    tempStateDir = fs.mkdtempSync(path.join(os.tmpdir(), "openclaw-doctor-state-"));
+    process.env.POOLBOT_STATE_DIR = tempStateDir;
+    fs.mkdirSync(path.join(tempStateDir, "agents", "main", "sessions"), {
+        recursive: true,
+    });
+    fs.mkdirSync(path.join(tempStateDir, "credentials"), { recursive: true });
+});
+afterEach(() => {
+    setStdinTty(originalIsTTY);
+    if (originalStateDir === undefined) {
+        delete process.env.POOLBOT_STATE_DIR;
+    }
+    else {
+        process.env.POOLBOT_STATE_DIR = originalStateDir;
+    }
+    if (originalUpdateInProgress === undefined) {
+        delete process.env.POOLBOT_UPDATE_IN_PROGRESS;
+    }
+    else {
+        process.env.POOLBOT_UPDATE_IN_PROGRESS = originalUpdateInProgress;
+    }
+    if (tempStateDir) {
+        fs.rmSync(tempStateDir, { recursive: true, force: true });
+        tempStateDir = undefined;
+    }
+});

package/dist/commands/gateway-presence.js

@@ -0,0 +1,19 @@
+export function pickGatewaySelfPresence(presence) {
+    if (!Array.isArray(presence)) {
+        return null;
+    }
+    const entries = presence;
+    const self = entries.find((e) => e.mode === "gateway" && e.reason === "self") ??
+        // Back-compat: older presence payloads only included a `text` line.
+        entries.find((e) => typeof e.text === "string" && String(e.text).startsWith("Gateway:")) ??
+        null;
+    if (!self) {
+        return null;
+    }
+    return {
+        host: typeof self.host === "string" ? self.host : undefined,
+        ip: typeof self.ip === "string" ? self.ip : undefined,
+        version: typeof self.version === "string" ? self.version : undefined,
+        platform: typeof self.platform === "string" ? self.platform : undefined,
+    };
+}

package/dist/commands/model-default.js

@@ -0,0 +1,35 @@
+export function resolvePrimaryModel(model) {
+    if (typeof model === "string") {
+        return model;
+    }
+    if (model && typeof model === "object" && typeof model.primary === "string") {
+        return model.primary;
+    }
+    return undefined;
+}
+export function applyAgentDefaultPrimaryModel(params) {
+    const current = resolvePrimaryModel(params.cfg.agents?.defaults?.model)?.trim();
+    const normalizedCurrent = current && params.legacyModels?.has(current) ? params.model : current;
+    if (normalizedCurrent === params.model) {
+        return { next: params.cfg, changed: false };
+    }
+    return {
+        next: {
+            ...params.cfg,
+            agents: {
+                ...params.cfg.agents,
+                defaults: {
+                    ...params.cfg.agents?.defaults,
+                    model: params.cfg.agents?.defaults?.model &&
+                        typeof params.cfg.agents.defaults.model === "object"
+                        ? {
+                            ...params.cfg.agents.defaults.model,
+                            primary: params.model,
+                        }
+                        : { primary: params.model },
+                },
+            },
+        },
+        changed: true,
+    };
+}

package/dist/commands/models/fallbacks-shared.js

@@ -0,0 +1,102 @@
+import { buildModelAliasIndex, resolveModelRefFromString } from "../../agents/model-selection.js";
+import { loadConfig } from "../../config/config.js";
+import { logConfigUpdated } from "../../config/logging.js";
+import { DEFAULT_PROVIDER, ensureFlagCompatibility, mergePrimaryFallbackConfig, modelKey, resolveModelTarget, resolveModelKeysFromEntries, updateConfig, } from "./shared.js";
+function getFallbacks(cfg, key) {
+    const entry = cfg.agents?.defaults?.[key];
+    return entry?.fallbacks ?? [];
+}
+function patchDefaultsFallbacks(cfg, params) {
+    const existing = cfg.agents?.defaults?.[params.key];
+    return {
+        ...cfg,
+        agents: {
+            ...cfg.agents,
+            defaults: {
+                ...cfg.agents?.defaults,
+                [params.key]: mergePrimaryFallbackConfig(existing, { fallbacks: params.fallbacks }),
+                ...(params.models ? { models: params.models } : undefined),
+            },
+        },
+    };
+}
+export async function listFallbacksCommand(params, opts, runtime) {
+    ensureFlagCompatibility(opts);
+    const cfg = loadConfig();
+    const fallbacks = getFallbacks(cfg, params.key);
+    if (opts.json) {
+        runtime.log(JSON.stringify({ fallbacks }, null, 2));
+        return;
+    }
+    if (opts.plain) {
+        for (const entry of fallbacks) {
+            runtime.log(entry);
+        }
+        return;
+    }
+    runtime.log(`${params.label} (${fallbacks.length}):`);
+    if (fallbacks.length === 0) {
+        runtime.log("- none");
+        return;
+    }
+    for (const entry of fallbacks) {
+        runtime.log(`- ${entry}`);
+    }
+}
+export async function addFallbackCommand(params, modelRaw, runtime) {
+    const updated = await updateConfig((cfg) => {
+        const resolved = resolveModelTarget({ raw: modelRaw, cfg });
+        const targetKey = modelKey(resolved.provider, resolved.model);
+        const nextModels = { ...cfg.agents?.defaults?.models };
+        if (!nextModels[targetKey]) {
+            nextModels[targetKey] = {};
+        }
+        const existing = getFallbacks(cfg, params.key);
+        const existingKeys = resolveModelKeysFromEntries({ cfg, entries: existing });
+        if (existingKeys.includes(targetKey)) {
+            return cfg;
+        }
+        return patchDefaultsFallbacks(cfg, {
+            key: params.key,
+            fallbacks: [...existing, targetKey],
+            models: nextModels,
+        });
+    });
+    logConfigUpdated(runtime);
+    runtime.log(`${params.logPrefix}: ${getFallbacks(updated, params.key).join(", ")}`);
+}
+export async function removeFallbackCommand(params, modelRaw, runtime) {
+    const updated = await updateConfig((cfg) => {
+        const resolved = resolveModelTarget({ raw: modelRaw, cfg });
+        const targetKey = modelKey(resolved.provider, resolved.model);
+        const aliasIndex = buildModelAliasIndex({
+            cfg,
+            defaultProvider: DEFAULT_PROVIDER,
+        });
+        const existing = getFallbacks(cfg, params.key);
+        const filtered = existing.filter((entry) => {
+            const resolvedEntry = resolveModelRefFromString({
+                raw: String(entry ?? ""),
+                defaultProvider: DEFAULT_PROVIDER,
+                aliasIndex,
+            });
+            if (!resolvedEntry) {
+                return true;
+            }
+            return modelKey(resolvedEntry.ref.provider, resolvedEntry.ref.model) !== targetKey;
+        });
+        if (filtered.length === existing.length) {
+            throw new Error(`${params.notFoundLabel} not found: ${targetKey}`);
+        }
+        return patchDefaultsFallbacks(cfg, { key: params.key, fallbacks: filtered });
+    });
+    logConfigUpdated(runtime);
+    runtime.log(`${params.logPrefix}: ${getFallbacks(updated, params.key).join(", ")}`);
+}
+export async function clearFallbacksCommand(params, runtime) {
+    await updateConfig((cfg) => {
+        return patchDefaultsFallbacks(cfg, { key: params.key, fallbacks: [] });
+    });
+    logConfigUpdated(runtime);
+    runtime.log(params.clearedMessage);
+}

package/dist/commands/models/shared.js

@@ -98,6 +98,30 @@ export const isLocalBaseUrl = (baseUrl) => {
 };
 export { modelKey };
 export { DEFAULT_MODEL, DEFAULT_PROVIDER };
+export function resolveModelKeysFromEntries(params) {
+    const aliasIndex = buildModelAliasIndex({
+        cfg: params.cfg,
+        defaultProvider: DEFAULT_PROVIDER,
+    });
+    return params.entries
+        .map((entry) => resolveModelRefFromString({
+        raw: entry,
+        defaultProvider: DEFAULT_PROVIDER,
+        aliasIndex,
+    }))
+        .filter((entry) => Boolean(entry))
+        .map((entry) => modelKey(entry.ref.provider, entry.ref.model));
+}
+export function mergePrimaryFallbackConfig(existing, patch) {
+    const next = { ...existing };
+    if (patch.primary !== undefined) {
+        next.primary = patch.primary;
+    }
+    if (patch.fallbacks !== undefined) {
+        next.fallbacks = patch.fallbacks;
+    }
+    return next;
+}
 /**
  * Model key format: "provider/model"
  *

package/dist/commands/onboard-auth.config-gateways.js

@@ -0,0 +1,64 @@
+import { buildCloudflareAiGatewayModelDefinition, resolveCloudflareAiGatewayBaseUrl, } from "../agents/cloudflare-ai-gateway.js";
+import { applyAgentDefaultModelPrimary, applyProviderConfigWithDefaultModel, } from "./onboard-auth.config-shared.js";
+import { CLOUDFLARE_AI_GATEWAY_DEFAULT_MODEL_REF, VERCEL_AI_GATEWAY_DEFAULT_MODEL_REF, } from "./onboard-auth.credentials.js";
+export function applyVercelAiGatewayProviderConfig(cfg) {
+    const models = { ...cfg.agents?.defaults?.models };
+    models[VERCEL_AI_GATEWAY_DEFAULT_MODEL_REF] = {
+        ...models[VERCEL_AI_GATEWAY_DEFAULT_MODEL_REF],
+        alias: models[VERCEL_AI_GATEWAY_DEFAULT_MODEL_REF]?.alias ?? "Vercel AI Gateway",
+    };
+    return {
+        ...cfg,
+        agents: {
+            ...cfg.agents,
+            defaults: {
+                ...cfg.agents?.defaults,
+                models,
+            },
+        },
+    };
+}
+export function applyCloudflareAiGatewayProviderConfig(cfg, params) {
+    const models = { ...cfg.agents?.defaults?.models };
+    models[CLOUDFLARE_AI_GATEWAY_DEFAULT_MODEL_REF] = {
+        ...models[CLOUDFLARE_AI_GATEWAY_DEFAULT_MODEL_REF],
+        alias: models[CLOUDFLARE_AI_GATEWAY_DEFAULT_MODEL_REF]?.alias ?? "Cloudflare AI Gateway",
+    };
+    const defaultModel = buildCloudflareAiGatewayModelDefinition();
+    const existingProvider = cfg.models?.providers?.["cloudflare-ai-gateway"];
+    const baseUrl = params?.accountId && params?.gatewayId
+        ? resolveCloudflareAiGatewayBaseUrl({
+            accountId: params.accountId,
+            gatewayId: params.gatewayId,
+        })
+        : typeof existingProvider?.baseUrl === "string"
+            ? existingProvider.baseUrl
+            : undefined;
+    if (!baseUrl) {
+        return {
+            ...cfg,
+            agents: {
+                ...cfg.agents,
+                defaults: {
+                    ...cfg.agents?.defaults,
+                    models,
+                },
+            },
+        };
+    }
+    return applyProviderConfigWithDefaultModel(cfg, {
+        agentModels: models,
+        providerId: "cloudflare-ai-gateway",
+        api: "anthropic-messages",
+        baseUrl,
+        defaultModel,
+    });
+}
+export function applyVercelAiGatewayConfig(cfg) {
+    const next = applyVercelAiGatewayProviderConfig(cfg);
+    return applyAgentDefaultModelPrimary(next, VERCEL_AI_GATEWAY_DEFAULT_MODEL_REF);
+}
+export function applyCloudflareAiGatewayConfig(cfg, params) {
+    const next = applyCloudflareAiGatewayProviderConfig(cfg, params);
+    return applyAgentDefaultModelPrimary(next, CLOUDFLARE_AI_GATEWAY_DEFAULT_MODEL_REF);
+}

package/dist/commands/onboard-auth.config-litellm.js

@@ -0,0 +1,45 @@
+import { applyAgentDefaultModelPrimary, applyProviderConfigWithDefaultModel, } from "./onboard-auth.config-shared.js";
+import { LITELLM_DEFAULT_MODEL_REF } from "./onboard-auth.credentials.js";
+export const LITELLM_BASE_URL = "http://localhost:4000";
+export const LITELLM_DEFAULT_MODEL_ID = "claude-opus-4-6";
+const LITELLM_DEFAULT_CONTEXT_WINDOW = 128_000;
+const LITELLM_DEFAULT_MAX_TOKENS = 8_192;
+const LITELLM_DEFAULT_COST = {
+    input: 0,
+    output: 0,
+    cacheRead: 0,
+    cacheWrite: 0,
+};
+function buildLitellmModelDefinition() {
+    return {
+        id: LITELLM_DEFAULT_MODEL_ID,
+        name: "Claude Opus 4.6",
+        reasoning: true,
+        input: ["text", "image"],
+        cost: LITELLM_DEFAULT_COST,
+        contextWindow: LITELLM_DEFAULT_CONTEXT_WINDOW,
+        maxTokens: LITELLM_DEFAULT_MAX_TOKENS,
+    };
+}
+export function applyLitellmProviderConfig(cfg) {
+    const models = { ...cfg.agents?.defaults?.models };
+    models[LITELLM_DEFAULT_MODEL_REF] = {
+        ...models[LITELLM_DEFAULT_MODEL_REF],
+        alias: models[LITELLM_DEFAULT_MODEL_REF]?.alias ?? "LiteLLM",
+    };
+    const defaultModel = buildLitellmModelDefinition();
+    const existingProvider = cfg.models?.providers?.litellm;
+    const resolvedBaseUrl = typeof existingProvider?.baseUrl === "string" ? existingProvider.baseUrl.trim() : "";
+    return applyProviderConfigWithDefaultModel(cfg, {
+        agentModels: models,
+        providerId: "litellm",
+        api: "openai-completions",
+        baseUrl: resolvedBaseUrl || LITELLM_BASE_URL,
+        defaultModel,
+        defaultModelId: LITELLM_DEFAULT_MODEL_ID,
+    });
+}
+export function applyLitellmConfig(cfg) {
+    const next = applyLitellmProviderConfig(cfg);
+    return applyAgentDefaultModelPrimary(next, LITELLM_DEFAULT_MODEL_REF);
+}