openclawdreams 2.3.0 → 2.4.0

package/dist/openclaw/src/agents/auth-profiles/order.d.ts

@@ -1,22 +0,0 @@
-import type { OpenClawConfig } from "../../config/config.js";
-import { type AuthCredentialReasonCode } from "./credential-state.js";
-import type { AuthProfileStore } from "./types.js";
-export type AuthProfileEligibilityReasonCode = AuthCredentialReasonCode | "profile_missing" | "provider_mismatch" | "mode_mismatch";
-export type AuthProfileEligibility = {
-    eligible: boolean;
-    reasonCode: AuthProfileEligibilityReasonCode;
-};
-export declare function resolveAuthProfileEligibility(params: {
-    cfg?: OpenClawConfig;
-    store: AuthProfileStore;
-    provider: string;
-    profileId: string;
-    now?: number;
-}): AuthProfileEligibility;
-export declare function resolveAuthProfileOrder(params: {
-    cfg?: OpenClawConfig;
-    store: AuthProfileStore;
-    provider: string;
-    preferredProfile?: string;
-}): string[];
-//# sourceMappingURL=order.d.ts.map

package/dist/openclaw/src/agents/auth-profiles/order.js

@@ -1,152 +0,0 @@
-import { findNormalizedProviderValue, normalizeProviderId, normalizeProviderIdForAuth, } from "../model-selection.js";
-import { evaluateStoredCredentialEligibility, } from "./credential-state.js";
-import { dedupeProfileIds, listProfilesForProvider } from "./profiles.js";
-import { clearExpiredCooldowns, isProfileInCooldown, resolveProfileUnusableUntil, } from "./usage.js";
-export function resolveAuthProfileEligibility(params) {
-    const providerAuthKey = normalizeProviderIdForAuth(params.provider);
-    const cred = params.store.profiles[params.profileId];
-    if (!cred) {
-        return { eligible: false, reasonCode: "profile_missing" };
-    }
-    if (normalizeProviderIdForAuth(cred.provider) !== providerAuthKey) {
-        return { eligible: false, reasonCode: "provider_mismatch" };
-    }
-    const profileConfig = params.cfg?.auth?.profiles?.[params.profileId];
-    if (profileConfig) {
-        if (normalizeProviderIdForAuth(profileConfig.provider) !== providerAuthKey) {
-            return { eligible: false, reasonCode: "provider_mismatch" };
-        }
-        if (profileConfig.mode !== cred.type) {
-            const oauthCompatible = profileConfig.mode === "oauth" && cred.type === "token";
-            if (!oauthCompatible) {
-                return { eligible: false, reasonCode: "mode_mismatch" };
-            }
-        }
-    }
-    const credentialEligibility = evaluateStoredCredentialEligibility({
-        credential: cred,
-        now: params.now,
-    });
-    return {
-        eligible: credentialEligibility.eligible,
-        reasonCode: credentialEligibility.reasonCode,
-    };
-}
-export function resolveAuthProfileOrder(params) {
-    const { cfg, store, provider, preferredProfile } = params;
-    const providerKey = normalizeProviderId(provider);
-    const providerAuthKey = normalizeProviderIdForAuth(provider);
-    const now = Date.now();
-    // Clear any cooldowns that have expired since the last check so profiles
-    // get a fresh error count and are not immediately re-penalized on the
-    // next transient failure. See #3604.
-    clearExpiredCooldowns(store, now);
-    const storedOrder = findNormalizedProviderValue(store.order, providerKey);
-    const configuredOrder = findNormalizedProviderValue(cfg?.auth?.order, providerKey);
-    const explicitOrder = storedOrder ?? configuredOrder;
-    const explicitProfiles = cfg?.auth?.profiles
-        ? Object.entries(cfg.auth.profiles)
-            .filter(([, profile]) => normalizeProviderIdForAuth(profile.provider) === providerAuthKey)
-            .map(([profileId]) => profileId)
-        : [];
-    const baseOrder = explicitOrder ??
-        (explicitProfiles.length > 0 ? explicitProfiles : listProfilesForProvider(store, provider));
-    if (baseOrder.length === 0) {
-        return [];
-    }
-    const isValidProfile = (profileId) => resolveAuthProfileEligibility({
-        cfg,
-        store,
-        provider: providerAuthKey,
-        profileId,
-        now,
-    }).eligible;
-    let filtered = baseOrder.filter(isValidProfile);
-    // Repair config/store profile-id drift from older onboarding flows:
-    // if configured profile ids no longer exist in auth-profiles.json, scan the
-    // provider's stored credentials and use any valid entries.
-    const allBaseProfilesMissing = baseOrder.every((profileId) => !store.profiles[profileId]);
-    if (filtered.length === 0 && explicitProfiles.length > 0 && allBaseProfilesMissing) {
-        const storeProfiles = listProfilesForProvider(store, provider);
-        filtered = storeProfiles.filter(isValidProfile);
-    }
-    const deduped = dedupeProfileIds(filtered);
-    // If user specified explicit order (store override or config), respect it
-    // exactly, but still apply cooldown sorting to avoid repeatedly selecting
-    // known-bad/rate-limited keys as the first candidate.
-    if (explicitOrder && explicitOrder.length > 0) {
-        // ...but still respect cooldown tracking to avoid repeatedly selecting a
-        // known-bad/rate-limited key as the first candidate.
-        const available = [];
-        const inCooldown = [];
-        for (const profileId of deduped) {
-            if (isProfileInCooldown(store, profileId)) {
-                const cooldownUntil = resolveProfileUnusableUntil(store.usageStats?.[profileId] ?? {}) ?? now;
-                inCooldown.push({ profileId, cooldownUntil });
-            }
-            else {
-                available.push(profileId);
-            }
-        }
-        const cooldownSorted = inCooldown
-            .toSorted((a, b) => a.cooldownUntil - b.cooldownUntil)
-            .map((entry) => entry.profileId);
-        const ordered = [...available, ...cooldownSorted];
-        // Still put preferredProfile first if specified
-        if (preferredProfile && ordered.includes(preferredProfile)) {
-            return [preferredProfile, ...ordered.filter((e) => e !== preferredProfile)];
-        }
-        return ordered;
-    }
-    // Otherwise, use round-robin: sort by lastUsed (oldest first)
-    // preferredProfile goes first if specified (for explicit user choice)
-    // lastGood is NOT prioritized - that would defeat round-robin
-    const sorted = orderProfilesByMode(deduped, store);
-    if (preferredProfile && sorted.includes(preferredProfile)) {
-        return [preferredProfile, ...sorted.filter((e) => e !== preferredProfile)];
-    }
-    return sorted;
-}
-function orderProfilesByMode(order, store) {
-    const now = Date.now();
-    // Partition into available and in-cooldown
-    const available = [];
-    const inCooldown = [];
-    for (const profileId of order) {
-        if (isProfileInCooldown(store, profileId)) {
-            inCooldown.push(profileId);
-        }
-        else {
-            available.push(profileId);
-        }
-    }
-    // Sort available profiles by type preference, then by lastUsed (oldest first = round-robin within type)
-    const scored = available.map((profileId) => {
-        const type = store.profiles[profileId]?.type;
-        const typeScore = type === "oauth" ? 0 : type === "token" ? 1 : type === "api_key" ? 2 : 3;
-        const lastUsed = store.usageStats?.[profileId]?.lastUsed ?? 0;
-        return { profileId, typeScore, lastUsed };
-    });
-    // Primary sort: type preference (oauth > token > api_key).
-    // Secondary sort: lastUsed (oldest first for round-robin within type).
-    const sorted = scored
-        .toSorted((a, b) => {
-        // First by type (oauth > token > api_key)
-        if (a.typeScore !== b.typeScore) {
-            return a.typeScore - b.typeScore;
-        }
-        // Then by lastUsed (oldest first)
-        return a.lastUsed - b.lastUsed;
-    })
-        .map((entry) => entry.profileId);
-    // Append cooldown profiles at the end (sorted by cooldown expiry, soonest first)
-    const cooldownSorted = inCooldown
-        .map((profileId) => ({
-        profileId,
-        cooldownUntil: resolveProfileUnusableUntil(store.usageStats?.[profileId] ?? {}) ?? now,
-    }))
-        .toSorted((a, b) => a.cooldownUntil - b.cooldownUntil)
-        .map((entry) => entry.profileId);
-    return [...sorted, ...cooldownSorted];
-}
-//# sourceMappingURL=order.js.map

package/dist/openclaw/src/agents/auth-profiles/paths.d.ts

@@ -1,5 +0,0 @@
-export declare function resolveAuthStorePath(agentDir?: string): string;
-export declare function resolveLegacyAuthStorePath(agentDir?: string): string;
-export declare function resolveAuthStorePathForDisplay(agentDir?: string): string;
-export declare function ensureAuthStoreFile(pathname: string): void;
-//# sourceMappingURL=paths.d.ts.map

package/dist/openclaw/src/agents/auth-profiles/paths.js

@@ -1,29 +0,0 @@
-import fs from "node:fs";
-import path from "node:path";
-import { saveJsonFile } from "../../infra/json-file.js";
-import { resolveUserPath } from "../../utils.js";
-import { resolveOpenClawAgentDir } from "../agent-paths.js";
-import { AUTH_PROFILE_FILENAME, AUTH_STORE_VERSION, LEGACY_AUTH_FILENAME } from "./constants.js";
-export function resolveAuthStorePath(agentDir) {
-    const resolved = resolveUserPath(agentDir ?? resolveOpenClawAgentDir());
-    return path.join(resolved, AUTH_PROFILE_FILENAME);
-}
-export function resolveLegacyAuthStorePath(agentDir) {
-    const resolved = resolveUserPath(agentDir ?? resolveOpenClawAgentDir());
-    return path.join(resolved, LEGACY_AUTH_FILENAME);
-}
-export function resolveAuthStorePathForDisplay(agentDir) {
-    const pathname = resolveAuthStorePath(agentDir);
-    return pathname.startsWith("~") ? pathname : resolveUserPath(pathname);
-}
-export function ensureAuthStoreFile(pathname) {
-    if (fs.existsSync(pathname)) {
-        return;
-    }
-    const payload = {
-        version: AUTH_STORE_VERSION,
-        profiles: {},
-    };
-    saveJsonFile(pathname, payload);
-}
-//# sourceMappingURL=paths.js.map

package/dist/openclaw/src/agents/auth-profiles/profiles.d.ts

@@ -1,25 +0,0 @@
-import type { AuthProfileCredential, AuthProfileStore } from "./types.js";
-export declare function dedupeProfileIds(profileIds: string[]): string[];
-export declare function setAuthProfileOrder(params: {
-    agentDir?: string;
-    provider: string;
-    order?: string[] | null;
-}): Promise<AuthProfileStore | null>;
-export declare function upsertAuthProfile(params: {
-    profileId: string;
-    credential: AuthProfileCredential;
-    agentDir?: string;
-}): void;
-export declare function upsertAuthProfileWithLock(params: {
-    profileId: string;
-    credential: AuthProfileCredential;
-    agentDir?: string;
-}): Promise<AuthProfileStore | null>;
-export declare function listProfilesForProvider(store: AuthProfileStore, provider: string): string[];
-export declare function markAuthProfileGood(params: {
-    store: AuthProfileStore;
-    provider: string;
-    profileId: string;
-    agentDir?: string;
-}): Promise<void>;
-//# sourceMappingURL=profiles.d.ts.map

package/dist/openclaw/src/agents/auth-profiles/profiles.js

@@ -1,86 +0,0 @@
-import { normalizeSecretInput } from "../../utils/normalize-secret-input.js";
-import { normalizeProviderId, normalizeProviderIdForAuth } from "../model-selection.js";
-import { ensureAuthProfileStore, saveAuthProfileStore, updateAuthProfileStoreWithLock, } from "./store.js";
-export function dedupeProfileIds(profileIds) {
-    return [...new Set(profileIds)];
-}
-export async function setAuthProfileOrder(params) {
-    const providerKey = normalizeProviderId(params.provider);
-    const sanitized = params.order && Array.isArray(params.order)
-        ? params.order.map((entry) => String(entry).trim()).filter(Boolean)
-        : [];
-    const deduped = dedupeProfileIds(sanitized);
-    return await updateAuthProfileStoreWithLock({
-        agentDir: params.agentDir,
-        updater: (store) => {
-            store.order = store.order ?? {};
-            if (deduped.length === 0) {
-                if (!store.order[providerKey]) {
-                    return false;
-                }
-                delete store.order[providerKey];
-                if (Object.keys(store.order).length === 0) {
-                    store.order = undefined;
-                }
-                return true;
-            }
-            store.order[providerKey] = deduped;
-            return true;
-        },
-    });
-}
-export function upsertAuthProfile(params) {
-    const credential = params.credential.type === "api_key"
-        ? {
-            ...params.credential,
-            ...(typeof params.credential.key === "string"
-                ? { key: normalizeSecretInput(params.credential.key) }
-                : {}),
-        }
-        : params.credential.type === "token"
-            ? { ...params.credential, token: normalizeSecretInput(params.credential.token) }
-            : params.credential;
-    const store = ensureAuthProfileStore(params.agentDir);
-    store.profiles[params.profileId] = credential;
-    saveAuthProfileStore(store, params.agentDir);
-}
-export async function upsertAuthProfileWithLock(params) {
-    return await updateAuthProfileStoreWithLock({
-        agentDir: params.agentDir,
-        updater: (store) => {
-            store.profiles[params.profileId] = params.credential;
-            return true;
-        },
-    });
-}
-export function listProfilesForProvider(store, provider) {
-    const providerKey = normalizeProviderIdForAuth(provider);
-    return Object.entries(store.profiles)
-        .filter(([, cred]) => normalizeProviderIdForAuth(cred.provider) === providerKey)
-        .map(([id]) => id);
-}
-export async function markAuthProfileGood(params) {
-    const { store, provider, profileId, agentDir } = params;
-    const updated = await updateAuthProfileStoreWithLock({
-        agentDir,
-        updater: (freshStore) => {
-            const profile = freshStore.profiles[profileId];
-            if (!profile || profile.provider !== provider) {
-                return false;
-            }
-            freshStore.lastGood = { ...freshStore.lastGood, [provider]: profileId };
-            return true;
-        },
-    });
-    if (updated) {
-        store.lastGood = updated.lastGood;
-        return;
-    }
-    const profile = store.profiles[profileId];
-    if (!profile || profile.provider !== provider) {
-        return;
-    }
-    store.lastGood = { ...store.lastGood, [provider]: profileId };
-    saveAuthProfileStore(store, agentDir);
-}
-//# sourceMappingURL=profiles.js.map

package/dist/openclaw/src/agents/auth-profiles/repair.d.ts

@@ -1,15 +0,0 @@
-import type { OpenClawConfig } from "../../config/config.js";
-import type { AuthProfileIdRepairResult, AuthProfileStore } from "./types.js";
-export declare function suggestOAuthProfileIdForLegacyDefault(params: {
-    cfg?: OpenClawConfig;
-    store: AuthProfileStore;
-    provider: string;
-    legacyProfileId: string;
-}): string | null;
-export declare function repairOAuthProfileIdMismatch(params: {
-    cfg: OpenClawConfig;
-    store: AuthProfileStore;
-    provider: string;
-    legacyProfileId?: string;
-}): AuthProfileIdRepairResult;
-//# sourceMappingURL=repair.d.ts.map

package/dist/openclaw/src/agents/auth-profiles/repair.js

@@ -1,129 +0,0 @@
-import { findNormalizedProviderKey, normalizeProviderId } from "../model-selection.js";
-import { dedupeProfileIds, listProfilesForProvider } from "./profiles.js";
-function getProfileSuffix(profileId) {
-    const idx = profileId.indexOf(":");
-    if (idx < 0) {
-        return "";
-    }
-    return profileId.slice(idx + 1);
-}
-function isEmailLike(value) {
-    const trimmed = value.trim();
-    if (!trimmed) {
-        return false;
-    }
-    return trimmed.includes("@") && trimmed.includes(".");
-}
-export function suggestOAuthProfileIdForLegacyDefault(params) {
-    const providerKey = normalizeProviderId(params.provider);
-    const legacySuffix = getProfileSuffix(params.legacyProfileId);
-    if (legacySuffix !== "default") {
-        return null;
-    }
-    const legacyCfg = params.cfg?.auth?.profiles?.[params.legacyProfileId];
-    if (legacyCfg &&
-        normalizeProviderId(legacyCfg.provider) === providerKey &&
-        legacyCfg.mode !== "oauth") {
-        return null;
-    }
-    const oauthProfiles = listProfilesForProvider(params.store, providerKey).filter((id) => params.store.profiles[id]?.type === "oauth");
-    if (oauthProfiles.length === 0) {
-        return null;
-    }
-    const configuredEmail = legacyCfg?.email?.trim();
-    if (configuredEmail) {
-        const byEmail = oauthProfiles.find((id) => {
-            const cred = params.store.profiles[id];
-            if (!cred || cred.type !== "oauth") {
-                return false;
-            }
-            const email = cred.email?.trim();
-            return email === configuredEmail || id === `${providerKey}:${configuredEmail}`;
-        });
-        if (byEmail) {
-            return byEmail;
-        }
-    }
-    const lastGood = params.store.lastGood?.[providerKey] ?? params.store.lastGood?.[params.provider];
-    if (lastGood && oauthProfiles.includes(lastGood)) {
-        return lastGood;
-    }
-    const nonLegacy = oauthProfiles.filter((id) => id !== params.legacyProfileId);
-    if (nonLegacy.length === 1) {
-        return nonLegacy[0] ?? null;
-    }
-    const emailLike = nonLegacy.filter((id) => isEmailLike(getProfileSuffix(id)));
-    if (emailLike.length === 1) {
-        return emailLike[0] ?? null;
-    }
-    return null;
-}
-export function repairOAuthProfileIdMismatch(params) {
-    const legacyProfileId = params.legacyProfileId ?? `${normalizeProviderId(params.provider)}:default`;
-    const legacyCfg = params.cfg.auth?.profiles?.[legacyProfileId];
-    if (!legacyCfg) {
-        return { config: params.cfg, changes: [], migrated: false };
-    }
-    if (legacyCfg.mode !== "oauth") {
-        return { config: params.cfg, changes: [], migrated: false };
-    }
-    if (normalizeProviderId(legacyCfg.provider) !== normalizeProviderId(params.provider)) {
-        return { config: params.cfg, changes: [], migrated: false };
-    }
-    const toProfileId = suggestOAuthProfileIdForLegacyDefault({
-        cfg: params.cfg,
-        store: params.store,
-        provider: params.provider,
-        legacyProfileId,
-    });
-    if (!toProfileId || toProfileId === legacyProfileId) {
-        return { config: params.cfg, changes: [], migrated: false };
-    }
-    const toCred = params.store.profiles[toProfileId];
-    const toEmail = toCred?.type === "oauth" ? toCred.email?.trim() : undefined;
-    const nextProfiles = {
-        ...params.cfg.auth?.profiles,
-    };
-    delete nextProfiles[legacyProfileId];
-    nextProfiles[toProfileId] = {
-        ...legacyCfg,
-        ...(toEmail ? { email: toEmail } : {}),
-    };
-    const providerKey = normalizeProviderId(params.provider);
-    const nextOrder = (() => {
-        const order = params.cfg.auth?.order;
-        if (!order) {
-            return undefined;
-        }
-        const resolvedKey = findNormalizedProviderKey(order, providerKey);
-        if (!resolvedKey) {
-            return order;
-        }
-        const existing = order[resolvedKey];
-        if (!Array.isArray(existing)) {
-            return order;
-        }
-        const replaced = existing
-            .map((id) => (id === legacyProfileId ? toProfileId : id))
-            .filter((id) => typeof id === "string" && id.trim().length > 0);
-        const deduped = dedupeProfileIds(replaced);
-        return { ...order, [resolvedKey]: deduped };
-    })();
-    const nextCfg = {
-        ...params.cfg,
-        auth: {
-            ...params.cfg.auth,
-            profiles: nextProfiles,
-            ...(nextOrder ? { order: nextOrder } : {}),
-        },
-    };
-    const changes = [`Auth: migrate ${legacyProfileId} → ${toProfileId} (OAuth profile id)`];
-    return {
-        config: nextCfg,
-        changes,
-        migrated: true,
-        fromProfileId: legacyProfileId,
-        toProfileId,
-    };
-}
-//# sourceMappingURL=repair.js.map

package/dist/openclaw/src/agents/auth-profiles/session-override.d.ts

@@ -1,19 +0,0 @@
-import type { OpenClawConfig } from "../../config/config.js";
-import { type SessionEntry } from "../../config/sessions.js";
-export declare function clearSessionAuthProfileOverride(params: {
-    sessionEntry: SessionEntry;
-    sessionStore: Record<string, SessionEntry>;
-    sessionKey: string;
-    storePath?: string;
-}): Promise<void>;
-export declare function resolveSessionAuthProfileOverride(params: {
-    cfg: OpenClawConfig;
-    provider: string;
-    agentDir: string;
-    sessionEntry?: SessionEntry;
-    sessionStore?: Record<string, SessionEntry>;
-    sessionKey?: string;
-    storePath?: string;
-    isNewSession: boolean;
-}): Promise<string | undefined>;
-//# sourceMappingURL=session-override.d.ts.map

package/dist/openclaw/src/agents/auth-profiles/session-override.js

@@ -1,104 +0,0 @@
-import { updateSessionStore } from "../../config/sessions.js";
-import { ensureAuthProfileStore, isProfileInCooldown, resolveAuthProfileOrder, } from "../auth-profiles.js";
-import { normalizeProviderId } from "../model-selection.js";
-function isProfileForProvider(params) {
-    const entry = params.store.profiles[params.profileId];
-    if (!entry?.provider) {
-        return false;
-    }
-    return normalizeProviderId(entry.provider) === normalizeProviderId(params.provider);
-}
-export async function clearSessionAuthProfileOverride(params) {
-    const { sessionEntry, sessionStore, sessionKey, storePath } = params;
-    delete sessionEntry.authProfileOverride;
-    delete sessionEntry.authProfileOverrideSource;
-    delete sessionEntry.authProfileOverrideCompactionCount;
-    sessionEntry.updatedAt = Date.now();
-    sessionStore[sessionKey] = sessionEntry;
-    if (storePath) {
-        await updateSessionStore(storePath, (store) => {
-            store[sessionKey] = sessionEntry;
-        });
-    }
-}
-export async function resolveSessionAuthProfileOverride(params) {
-    const { cfg, provider, agentDir, sessionEntry, sessionStore, sessionKey, storePath, isNewSession, } = params;
-    if (!sessionEntry || !sessionStore || !sessionKey) {
-        return sessionEntry?.authProfileOverride;
-    }
-    const store = ensureAuthProfileStore(agentDir, { allowKeychainPrompt: false });
-    const order = resolveAuthProfileOrder({ cfg, store, provider });
-    let current = sessionEntry.authProfileOverride?.trim();
-    if (current && !store.profiles[current]) {
-        await clearSessionAuthProfileOverride({ sessionEntry, sessionStore, sessionKey, storePath });
-        current = undefined;
-    }
-    if (current && !isProfileForProvider({ provider, profileId: current, store })) {
-        await clearSessionAuthProfileOverride({ sessionEntry, sessionStore, sessionKey, storePath });
-        current = undefined;
-    }
-    if (current && order.length > 0 && !order.includes(current)) {
-        await clearSessionAuthProfileOverride({ sessionEntry, sessionStore, sessionKey, storePath });
-        current = undefined;
-    }
-    if (order.length === 0) {
-        return undefined;
-    }
-    const pickFirstAvailable = () => order.find((profileId) => !isProfileInCooldown(store, profileId)) ?? order[0];
-    const pickNextAvailable = (active) => {
-        const startIndex = order.indexOf(active);
-        if (startIndex < 0) {
-            return pickFirstAvailable();
-        }
-        for (let offset = 1; offset <= order.length; offset += 1) {
-            const candidate = order[(startIndex + offset) % order.length];
-            if (!isProfileInCooldown(store, candidate)) {
-                return candidate;
-            }
-        }
-        return order[startIndex] ?? order[0];
-    };
-    const compactionCount = sessionEntry.compactionCount ?? 0;
-    const storedCompaction = typeof sessionEntry.authProfileOverrideCompactionCount === "number"
-        ? sessionEntry.authProfileOverrideCompactionCount
-        : compactionCount;
-    const source = sessionEntry.authProfileOverrideSource ??
-        (typeof sessionEntry.authProfileOverrideCompactionCount === "number"
-            ? "auto"
-            : current
-                ? "user"
-                : undefined);
-    if (source === "user" && current && !isNewSession) {
-        return current;
-    }
-    let next = current;
-    if (isNewSession) {
-        next = current ? pickNextAvailable(current) : pickFirstAvailable();
-    }
-    else if (current && compactionCount > storedCompaction) {
-        next = pickNextAvailable(current);
-    }
-    else if (!current || isProfileInCooldown(store, current)) {
-        next = pickFirstAvailable();
-    }
-    if (!next) {
-        return current;
-    }
-    const shouldPersist = next !== sessionEntry.authProfileOverride ||
-        sessionEntry.authProfileOverrideSource !== "auto" ||
-        sessionEntry.authProfileOverrideCompactionCount !== compactionCount;
-    if (shouldPersist) {
-        sessionEntry.authProfileOverride = next;
-        sessionEntry.authProfileOverrideSource = "auto";
-        sessionEntry.authProfileOverrideCompactionCount = compactionCount;
-        sessionEntry.updatedAt = Date.now();
-        sessionStore[sessionKey] = sessionEntry;
-        if (storePath) {
-            await updateSessionStore(storePath, (store) => {
-                store[sessionKey] = sessionEntry;
-            });
-        }
-    }
-    return next;
-}
-//# sourceMappingURL=session-override.js.map

package/dist/openclaw/src/agents/auth-profiles/store.d.ts

@@ -1,23 +0,0 @@
-import type { AuthProfileStore } from "./types.js";
-type LoadAuthProfileStoreOptions = {
-    allowKeychainPrompt?: boolean;
-    readOnly?: boolean;
-};
-export declare function replaceRuntimeAuthProfileStoreSnapshots(entries: Array<{
-    agentDir?: string;
-    store: AuthProfileStore;
-}>): void;
-export declare function clearRuntimeAuthProfileStoreSnapshots(): void;
-export declare function updateAuthProfileStoreWithLock(params: {
-    agentDir?: string;
-    updater: (store: AuthProfileStore) => boolean;
-}): Promise<AuthProfileStore | null>;
-export declare function loadAuthProfileStore(): AuthProfileStore;
-export declare function loadAuthProfileStoreForRuntime(agentDir?: string, options?: LoadAuthProfileStoreOptions): AuthProfileStore;
-export declare function loadAuthProfileStoreForSecretsRuntime(agentDir?: string): AuthProfileStore;
-export declare function ensureAuthProfileStore(agentDir?: string, options?: {
-    allowKeychainPrompt?: boolean;
-}): AuthProfileStore;
-export declare function saveAuthProfileStore(store: AuthProfileStore, agentDir?: string): void;
-export {};
-//# sourceMappingURL=store.d.ts.map