listProfilesForProvider,

markAuthProfileSuccess,

removeProviderAuthProfilesWithLock,

resolveSubscriptionAuthModeForProfiles,

setAuthProfileOrder,

upsertAuthProfile,

upsertAuthProfileWithLock,

.filter(([, cred]) => resolveProviderIdForAuth(cred.provider) === providerKey)

.map(([id]) => id);

}

export function resolveSubscriptionAuthModeForProfiles(params: {

store: AuthProfileStore;

profileIds: ReadonlyArray<string | undefined>;

}): "oauth" | "token" | undefined {

for (const profileId of params.profileIds) {

const type = profileId ? params.store.profiles[profileId]?.type : undefined;

if (type === "oauth" || type === "token") {

return type;

}

}

return undefined;

}

updateAuthProfileStoreWithLock,

} from "./store.js";

import type { AuthProfileCredential, AuthProfileStore, ProfileUsageStats } from "./types.js";

export { dedupeProfileIds, listProfilesForProvider } from "./profile-list.js";

export {

dedupeProfileIds,

listProfilesForProvider,

resolveSubscriptionAuthModeForProfiles,

} from "./profile-list.js";

// Auth profile order/lastGood keys may be stored as aliases. Resolve through

// auth provider normalization before updating per-provider state.

});

});

describe("formatBillingErrorMessage — authMode neutral copy (#80877)", () => {

// OAuth/Max users should NOT see "API key" or "top up" language.

it("returns neutral copy for oauth authMode — no 'API key' text", () => {

const result = formatBillingErrorMessage("Anthropic", "claude-sonnet-4-5", "oauth");

expect(result).not.toMatch(/api key/i);

expect(result).not.toMatch(/top up/i);

expect(result).toContain("check your account");

});

it("returns neutral copy for token authMode — no 'API key' text", () => {

const result = formatBillingErrorMessage("Anthropic", "claude-sonnet-4-5", "token");

expect(result).not.toMatch(/api key/i);

expect(result).not.toMatch(/top up/i);

});

it("REGRESSION: api_key authMode still returns 'API key' copy", () => {

const result = formatBillingErrorMessage("Anthropic", "claude-sonnet-4-5", "api_key");

expect(result).toMatch(/api key/i);

expect(result).toMatch(/top up/i);

});

it("REGRESSION: undefined authMode (legacy call-sites) still returns 'API key' copy", () => {

const result = formatBillingErrorMessage("Anthropic", "claude-sonnet-4-5");

expect(result).toMatch(/api key/i);

});

it("REGRESSION: no-provider call still returns generic 'API key' copy", () => {

const result = formatBillingErrorMessage();

expect(result).toMatch(/api key/i);

});

});

describe("sanitizeUserFacingText — streaming JSON parse error (#59076)", () => {

it("rewrites transport-classified malformed streaming fragments in error context", () => {

const result = sanitizeUserFacingText(MALFORMED_STREAMING_FRAGMENT_ERROR_MESSAGE, {

export function formatAssistantErrorText(

msg: AssistantMessage,

opts?: { cfg?: OpenClawConfig; sessionKey?: string; provider?: string; model?: string },

opts?: {

cfg?: OpenClawConfig;

sessionKey?: string;

provider?: string;

model?: string;

/** Credential auth mode (e.g. "oauth", "token", "api_key", "aws-sdk").

* When "oauth" or "token", billing copy omits API-key language (#80877). */

authMode?: string;

},

): string | undefined {

// Also format errors if errorMessage is present, even if stopReason isn't "error"

const raw = (msg.errorMessage ?? "").trim();

isOpenRouterKeyLimitExceededError(raw, opts?.provider) ||

isOpenRouterKeyBudgetLimitExceededError(raw, opts?.provider)

) {

return formatBillingErrorMessage(opts?.provider, opts?.model ?? msg.model);

return formatBillingErrorMessage(opts?.provider, opts?.model ?? msg.model, opts?.authMode);

}

if (isBilling429MessageForProvider(raw, opts?.provider)) {

return formatBillingErrorMessage(opts?.provider, opts?.model ?? msg.model);

return formatBillingErrorMessage(opts?.provider, opts?.model ?? msg.model, opts?.authMode);

}

const transientCopy = formatRateLimitOrOverloadedErrorCopy(raw);

}

if (isBillingErrorMessage(raw)) {

return formatBillingErrorMessage(opts?.provider, opts?.model ?? msg.model);

return formatBillingErrorMessage(opts?.provider, opts?.model ?? msg.model, opts?.authMode);

}

if (providerRuntimeFailureKind === "schema") {

export function formatUserFacingAssistantErrorText(

msg: AssistantMessage,

opts?: { cfg?: OpenClawConfig; sessionKey?: string; provider?: string; model?: string },

opts?: {

cfg?: OpenClawConfig;

sessionKey?: string;

provider?: string;

model?: string;

/** Credential auth mode for billing copy (#80877). */

authMode?: string;

},

): string {

const friendlyError = formatAssistantErrorText(msg, opts);

const rawError = msg.errorMessage?.trim();

isTimeoutErrorMessage,

} from "./failover-matches.js";

/** Format the billing failure copy with optional provider/model context. */

export function formatBillingErrorMessage(provider?: string, model?: string): string {

/** Format the billing failure copy with optional provider/model context.

*

* When `authMode` is `"oauth"` or `"token"` (i.e. Anthropic Max or a static

* bearer-token subscription) the user has no API key to top up, so we emit

* neutral copy that directs them to check their account instead (#80877).

*/

export function formatBillingErrorMessage(

provider?: string,

model?: string,

authMode?: string,

): string {

const providerName = provider?.trim();

const modelName = model?.trim();

const providerLabel =

providerName && modelName ? `${providerName} (${modelName})` : providerName || undefined;

// OAuth and static-token credentials do not have an API key to top up.

const isSubscriptionAuth = authMode === "oauth" || authMode === "token";

if (isSubscriptionAuth) {

if (providerLabel) {

return `⚠️ ${providerLabel} returned a billing error — check your account for subscription or usage limits, then try again.`;

}

return "⚠️ API provider returned a billing error — check your account for subscription or usage limits, then try again.";

}

if (providerLabel) {

return `⚠️ ${providerLabel} returned a billing error — your API key has run out of credits or has an insufficient balance. Check your ${providerName} billing dashboard and top up or switch to a different API key.`;

}

});

mockedRunEmbeddedAttempt.mockResolvedValue(makeAttemptResult({ promptError }));

mockedEnsureAuthProfileStoreWithoutExternalProfiles.mockReturnValue({

profiles: {

"test-profile": {

provider: "anthropic",

type: "oauth",

},

},

});

mockedCoerceToFailoverError.mockReturnValue(normalized);

mockedDescribeFailoverError.mockImplementation((err: unknown) => ({

message: err instanceof Error ? err.message : String(err),

provider: "anthropic",

model: "test-model",

profileId: "test-profile",

authMode: "oauth",

});

expect(mockedResolveFailoverStatus).toHaveBeenCalledWith("rate_limit");

});

sessionKey: resolvedSessionKey ?? params.sessionId,

provider: activeErrorContext.provider,

model: activeErrorContext.model,

authMode: lastProfileId

? attemptAuthProfileStore.profiles?.[lastProfileId]?.type

: undefined,

})

: undefined;

const assistantErrorText =

// promptErrorSource === "compaction" means the model call already completed and the

// abort happened only while waiting for compaction/retry cleanup. Retrying from here

// would replay that completed tool turn as a fresh prompt attempt.

const promptAuthMode = lastProfileId

? attemptAuthProfileStore.profiles?.[lastProfileId]?.type

: undefined;

const normalizedPromptFailover = coerceToFailoverError(promptError, {

provider: activeErrorContext.provider,

model: activeErrorContext.model,

profileId: lastProfileId,

authMode: promptAuthMode,

sessionId: sessionIdUsed,

lane: globalLane,

});

provider,

model: modelId,

profileId: lastProfileId,

authMode: promptAuthMode,

sessionId: sessionIdUsed,

lane: globalLane,

status,

authFailure,

rateLimitFailure,

billingFailure,

authMode: lastProfileId

? attemptAuthProfileStore.profiles?.[lastProfileId]?.type

: undefined,

cloudCodeAssistFormatError,

isProbeSession,

overloadProfileRotations,

sessionKey: params.sessionKey ?? params.sessionId,

provider: activeErrorContext.provider,

model: activeErrorContext.model,

authMode: lastProfileId

? attemptAuthProfileStore.profiles?.[lastProfileId]?.type

: undefined,

verboseLevel: params.verboseLevel,

reasoningLevel: params.reasoningLevel,

thinkingLevel: params.thinkLevel,

authFailure: boolean;

rateLimitFailure: boolean;

billingFailure: boolean;

/** Credential auth mode (e.g. "oauth", "token", "api_key") for billing copy (#80877). */

authMode?: string;

cloudCodeAssistFormatError: boolean;

isProbeSession: boolean;

overloadProfileRotations: number;

provider: params.activeErrorContext.provider,

model: params.activeErrorContext.model,

profileId: params.lastProfileId,

authMode: params.authMode,

status,

rawError: params.lastAssistant?.errorMessage?.trim(),

suspend: shouldSuspend,

provider: params.activeErrorContext.provider,

model: params.activeErrorContext.model,

profileId: params.lastProfileId,

authMode: params.authMode,

status,

rawError: params.lastAssistant?.errorMessage?.trim(),

suspend: shouldSuspend,

rateLimitFailure: boolean;

billingFailure: boolean;

authFailure: boolean;

/** Credential auth mode passed through to billing copy formatter (#80877). */

authMode?: string;

}): string {

const timeoutFailure = params.timedOut || params.idleTimedOut;

return (

sessionKey: params.sessionKey,

provider: params.activeErrorContext.provider,

model: params.activeErrorContext.model,

authMode: params.authMode,

})

: undefined) ||

params.lastAssistant?.errorMessage?.trim() ||

? formatBillingErrorMessage(

params.activeErrorContext.provider,

params.activeErrorContext.model,

params.authMode,

)

: params.authFailure

? "LLM request unauthorized."

import type { Model } from "openclaw/plugin-sdk/llm";

import { beforeEach, describe, expect, it, vi, type Mock } from "vitest";

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

import { FailoverError } from "../../failover-error.js";

import type { RuntimeAuthState } from "./helpers.js";

const mocks = vi.hoisted(() => ({

harness: MutableAuthControllerHarness;

setRuntimeApiKey: RuntimeApiKeySetter;

profileCandidates?: string[];

authStore?: AuthProfileStore;

fallbackConfigured?: boolean;

warn?: (message: string) => void;

}) {

return createEmbeddedRunAuthController({

config: undefined,

agentDir: "/tmp/agent",

workspaceDir: "/tmp/workspace",

authStore: {

version: 1,

profiles: {},

} as AuthProfileStore,

authStore:

params.authStore ??

({

version: 1,

profiles: {},

} as AuthProfileStore),

authStorage: { setRuntimeApiKey: params.setRuntimeApiKey },

profileCandidates: params.profileCandidates ?? ["default"],

initialThinkLevel: "medium",

attemptedThinking: new Set(),

fallbackConfigured: false,

fallbackConfigured: params.fallbackConfigured ?? false,

allowTransientCooldownProbe: false,

getProvider: () => "custom-openai",

getModelId: () => "test-model",

});

});

it("preserves OAuth mode when billing-disabled profiles are all unavailable", async () => {

const harness = createMutableAuthControllerHarness();

const profileId = "custom-openai:oauth";

const controller = createMutableEmbeddedRunAuthController({

harness,

setRuntimeApiKey: vi.fn(),

profileCandidates: [profileId],

fallbackConfigured: true,

authStore: {

version: 1,

profiles: {

[profileId]: {

type: "oauth",

provider: "custom-openai",

access: "access-token",

refresh: "refresh-token",

expires: Date.now() + 60_000,

},

},

usageStats: {

[profileId]: {

disabledUntil: Date.now() + 60_000,

disabledReason: "billing",

},

},

},

});

const error = await controller.initializeAuthProfile().catch((err: unknown) => err);

expect(error).toBeInstanceOf(FailoverError);

expect(error).toMatchObject({

reason: "billing",

authMode: "oauth",

});

});

it("rejects privileged runtime transport overrides on the first auth exchange", async () => {

let runtimeModel = createTestModel();