@mastra/code-sdk 0.0.0-aggregate-trace-20261015182851

package/dist/auth/account-rotation-processor.js

@@ -0,0 +1,609 @@
+import { getOAuthProviders } from "./storage.js";
+import { getCredentialProviderId, normalizeLegacyModelId } from "../providers/model-ids.js";
+import { ProviderAuthRequiredError } from "./provider-auth-error.js";
+import { resolveCredentialStore } from "../agents/credential-resolver.js";
+import { getRequestAccountSelection, isRequestAccountRoutingExhausted, markRequestAccountRoutingExhausted, setRequestAccountSelection } from "./account-routing-context.js";
+import { resolveModel, resolveRequestThinkingLevel } from "../agents/model.js";
+import { TripWire } from "@mastra/core/agent";
+//#region src/auth/account-rotation-processor.ts
+/**
+* Error-driven rotation across a provider's OAuth account registry.
+*
+* When the active account cannot serve a request (rate limit, quota
+* exhaustion, dead token, persistent outage), the next account in insertion
+* order is selected for the request and the request retried. OAuth fetch
+* wrappers read that request-scoped selection on every HTTP attempt, so
+* concurrent runs can't swap each other's credentials. Every switch is
+* persisted as a non-transient `data-mastracode-account-switch` part so it
+* shows in the transcript and survives history reload.
+*
+* Two classes, two lanes — the split is load-bearing. The processor runner
+* walks `[...inputProcessors, ...outputProcessors, ...errorProcessors]` when
+* running `processAPIError`, so a processor registered in the input lane that
+* also implemented `processAPIError` would run BEFORE
+* `StreamErrorRetryProcessor` and hop on 5xx errors before transient retries
+* had a chance. `AccountRotationProcessor` therefore implements
+* `processAPIError` only and is registered in `errorProcessors` after
+* `StreamErrorRetryProcessor`; `AccountStartNoticeProcessor` implements
+* `processInput` only and is registered in `inputProcessors`.
+*/
+const ACCOUNT_SWITCH_PART_TYPE = "data-mastracode-account-switch";
+/** Rotatable providers = the OAuth provider registry; API-key-only providers never rotate. */
+const KNOWN_PROVIDER_IDS = new Set(getOAuthProviders().map((provider) => provider.id));
+/** Hostname suffixes → provider ids, for `APICallError.url`. */
+const PROVIDER_HOST_PATTERNS = [
+	[/(^|\.)api\.anthropic\.com$/i, "anthropic"],
+	[/(^|\.)api\.kimi\.com$/i, "kimi-for-coding"],
+	[/(^|\.)api\.x\.ai$/i, "xai"],
+	[/(^|\.)chatgpt\.com$/i, "openai-codex"],
+	[/(^|\.)backend-api\.codex\.ai$/i, "openai-codex"],
+	[/(^|\.)githubcopilot\.com$/i, "github-copilot"],
+	[/(^|\.)api\.github\.com$/i, "github-copilot"]
+];
+/**
+* Provider usage/quota-limit wording (locked Q7 bucket 1). Statuses 429/402
+* are matched before this; some providers deliver quota errors as plain 400s,
+* which only the message reveals. Deliberately restricted to unambiguous
+* quota phrases — a generic "exceeded your … limit" can appear on non-quota
+* client errors (request size, context length) that must never rotate.
+*/
+const USAGE_LIMIT_MESSAGE_PATTERN = /usage (?:limit|cap)|insufficient[_ ]quota|quota (?:exceeded|exhausted|reached)|exceeded (?:your )?current quota|insufficient (?:balance|credits?)|credits? exhausted|rate limit (?:exceeded|reached)|weekly limit|monthly limit/i;
+const NETWORK_ERROR_CODES = /* @__PURE__ */ new Set([
+	"ECONNRESET",
+	"EPIPE",
+	"ECONNREFUSED",
+	"ENOTFOUND",
+	"ETIMEDOUT",
+	"EAI_AGAIN",
+	"UND_ERR_CONNECT_TIMEOUT",
+	"UND_ERR_SOCKET"
+]);
+const NETWORK_MESSAGE_PATTERN = /fetch failed|network error|socket hang up|getaddrinfo|econnrefused|enotfound|etimedout|connection (?:refused|reset|closed|timed out)|other side closed|write epipe/i;
+const MAX_CAUSE_DEPTH = 4;
+/** Persisted data-part type for a model-route hop. */
+const MODEL_FALLBACK_PART_TYPE = "data-mastracode-model-fallback";
+/** Session-state key set when account rotation advances the model route. */
+const MODEL_FALLBACK_STATE_KEY = "mastracodePendingModelFallback";
+function isErrorWithCode(error) {
+	return typeof error === "object" && error !== null && "code" in error;
+}
+function readErrorStatus(error) {
+	let current = error;
+	for (let depth = 0; current && depth < MAX_CAUSE_DEPTH; depth++) {
+		if (typeof current !== "object") break;
+		const { statusCode, status } = current;
+		if (typeof statusCode === "number") return statusCode;
+		if (typeof status === "number") return status;
+		current = current.cause;
+	}
+}
+function isProviderAuthRequiredError(error) {
+	let current = error;
+	for (let depth = 0; current && depth < MAX_CAUSE_DEPTH; depth++) {
+		if (current instanceof ProviderAuthRequiredError || current instanceof Error && current.name === "ProviderAuthRequiredError") return true;
+		if (typeof current !== "object") break;
+		current = current.cause;
+	}
+	return false;
+}
+/** Concatenate the error's message with its cause chain (bounded). */
+function collectErrorText(error) {
+	const parts = [];
+	let current = error;
+	for (let depth = 0; current && depth < MAX_CAUSE_DEPTH; depth++) if (current instanceof Error) {
+		parts.push(current.message);
+		current = current.cause;
+	} else if (typeof current === "object" && "message" in current) {
+		const message = current.message;
+		if (typeof message === "string") parts.push(message);
+		current = current.cause;
+	} else break;
+	return parts.join(" | ");
+}
+function isNetworkErrorLike(error) {
+	let current = error;
+	for (let depth = 0; current && depth < MAX_CAUSE_DEPTH; depth++) {
+		if (isErrorWithCode(current) && typeof current.code === "string" && NETWORK_ERROR_CODES.has(current.code.toUpperCase())) return true;
+		if (current instanceof Error) {
+			if (NETWORK_MESSAGE_PATTERN.test(current.message)) return true;
+			current = current.cause;
+		} else if (typeof current === "object") current = current.cause;
+		else break;
+	}
+	return false;
+}
+/**
+* The locked Q7 taxonomy. 429/402/usage-limit rotate immediately (429 is not
+* covered by any transient matcher, so it arrives here on first occurrence);
+* 401/403 and `ProviderAuthRequiredError` rotate after one forced refresh;
+* 5xx/network hop only when the transient retry budget is already spent (they
+* reach this processor because `StreamErrorRetryProcessor` declined); 400 and
+* everything unknown never touch the registry.
+*/
+function classifyRotationError(error) {
+	if (isProviderAuthRequiredError(error)) return {
+		kind: "rotate",
+		reason: "auth-failed"
+	};
+	const status = readErrorStatus(error);
+	if (status === 429) return {
+		kind: "rotate",
+		reason: "rate-limit"
+	};
+	if (status === 402) return {
+		kind: "rotate",
+		reason: "quota-exhausted"
+	};
+	if (status === 401 || status === 403) return {
+		kind: "rotate",
+		reason: "auth-failed"
+	};
+	if (status !== void 0 && status >= 500 && status < 600) return { kind: "hop" };
+	if (status === void 0 || status === 400) {
+		if (USAGE_LIMIT_MESSAGE_PATTERN.test(collectErrorText(error))) return {
+			kind: "rotate",
+			reason: "quota-exhausted"
+		};
+	}
+	if (isNetworkErrorLike(error)) return { kind: "hop" };
+	return { kind: "never" };
+}
+/** Provider id off a router model id: `mastracode/<provider>/<model>` or `<provider>/<model>`. */
+function providerFromModelId(modelId) {
+	const segments = normalizeLegacyModelId(modelId).replace(/^mastracode\//, "").split("/");
+	const providerId = segments[0] ? getCredentialProviderId(segments[0]) : void 0;
+	return providerId && KNOWN_PROVIDER_IDS.has(providerId) ? providerId : void 0;
+}
+function providerFromHost(hostname) {
+	for (const [pattern, providerId] of PROVIDER_HOST_PATTERNS) if (pattern.test(hostname)) return providerId;
+}
+/**
+* Identify the provider an error came from: the request URL's hostname
+* (`APICallError.url`, cause chain included), falling back to the router
+* model id. Unknown → undefined (caller treats as never-rotate).
+*/
+function providerFromError(error) {
+	const causeChain = [];
+	let current = error;
+	for (let depth = 0; current && depth < MAX_CAUSE_DEPTH; depth++) {
+		if (typeof current !== "object") break;
+		causeChain.push(current);
+		current = current.cause;
+	}
+	for (const item of causeChain) {
+		const urls = [
+			item.url,
+			item.requestURL,
+			item.requestUrl
+		];
+		for (const url of urls) {
+			if (typeof url !== "string") continue;
+			try {
+				const providerId = providerFromHost(new URL(url).hostname);
+				if (providerId) return providerId;
+			} catch {}
+		}
+	}
+	for (const item of causeChain) {
+		const modelId = item.modelId;
+		if (typeof modelId !== "string") continue;
+		const providerId = providerFromModelId(modelId);
+		if (providerId) return providerId;
+	}
+}
+function getTriedInstances(state) {
+	const existing = state.triedInstances;
+	if (existing instanceof Set) return existing;
+	const created = /* @__PURE__ */ new Set();
+	state.triedInstances = created;
+	return created;
+}
+function getForcedRefreshInstances(state) {
+	const existing = state.forcedAuthRefresh;
+	if (existing instanceof Set) return existing;
+	const created = /* @__PURE__ */ new Set();
+	state.forcedAuthRefresh = created;
+	return created;
+}
+/** Friendly names for the part/notice copy (display only — never auth data). */
+const PROVIDER_DISPLAY_NAMES = {
+	anthropic: "Anthropic",
+	"kimi-for-coding": "Kimi",
+	"openai-codex": "Codex",
+	"github-copilot": "GitHub Copilot",
+	xai: "xAI"
+};
+const REASON_TEXT = {
+	"rate-limit": "rate limit",
+	"quota-exhausted": "quota exhausted",
+	"auth-failed": "auth failed",
+	"pool-exhausted": "pool exhausted",
+	"persistent-outage": "persistent outage",
+	"preferred-routing": "subscription routing"
+};
+/** Validates untrusted `reason` values (e.g. persisted message parts). */
+function isAccountSwitchReason(value) {
+	return typeof value === "string" && Object.prototype.hasOwnProperty.call(REASON_TEXT, value);
+}
+/**
+* One-line transcript copy for a switch part. Shared by the live `info`
+* controller event (the TUI shows controller `info` events as transcript
+* lines, and no message event carries data parts mid-run) and by the TUI's
+* history rendering of the persisted part — one formatter, identical text.
+*/
+function accountSwitchNoticeText(data) {
+	const provider = PROVIDER_DISPLAY_NAMES[data.provider] ?? data.provider;
+	const reason = REASON_TEXT[data.reason];
+	if (data.to === null) {
+		if (data.exclusive) return `Pinned ${provider} account unavailable (${reason})`;
+		return `All ${provider} accounts unavailable (${reason})`;
+	}
+	return `Switched ${provider} account: ${data.from?.label ?? "unknown"} → ${data.to.label} (${reason})`;
+}
+/** Transcript line for a model-route hop; shared by the live info event and the TUI's history render. */
+function modelFallbackNoticeText(data) {
+	const reason = REASON_TEXT[data.reason] ?? data.reason;
+	return `Switched model route: ${data.from.label} → ${data.to.label} (${reason})`;
+}
+/**
+* Whether a persisted model-fallback reason is one this build understands.
+* `REASON_TEXT` also covers the account-switch reasons, so the notice text
+* alone would happily render a foreign value such as `rate-limit` as a
+* model-fallback reason; history parsed from another build's part must be
+* rejected instead.
+*/
+function isModelFallbackReason(value) {
+	return value === "pool-exhausted" || value === "persistent-outage";
+}
+async function emitAccountSwitchPart(args, data) {
+	await args.writer?.custom({
+		type: ACCOUNT_SWITCH_PART_TYPE,
+		data
+	});
+	(args.requestContext?.get("controller"))?.emitEvent?.({
+		type: "info",
+		message: accountSwitchNoticeText(data)
+	});
+}
+/**
+* Provider of the model the controller session is currently running — the
+* fallback identification path for errors that carry neither a request URL
+* nor a model id (e.g. `ProviderAuthRequiredError` thrown by a fetch wrapper
+* before any HTTP request exists).
+*/
+function providerFromSession(args) {
+	const modelId = (args.requestContext?.get("controller"))?.session?.modelId;
+	return typeof modelId === "string" ? providerFromModelId(modelId) : void 0;
+}
+function getRoutingController(args) {
+	return args.requestContext?.get("controller");
+}
+/** A targeted route is exclusive; an entry without accountId uses automatic pool rotation. */
+function getRouteTargetAccountId(route) {
+	return route?.accountId;
+}
+function getRequestActiveAccount(args, store, providerId) {
+	if (isRequestAccountRoutingExhausted(args.requestContext, providerId)) return void 0;
+	const selectedId = getRequestAccountSelection(args.requestContext, providerId);
+	if (selectedId) return store.listAccounts?.(providerId).find((account) => account.id === selectedId);
+	return store.getActiveAccount?.(providerId) ?? store.listAccounts?.(providerId).find((account) => account.active);
+}
+function resolveAccountRoute(args, explicit) {
+	const controller = getRoutingController(args);
+	const state = controller?.getState?.();
+	const pending = state?.mastracodePendingModelFallback;
+	const pendingMatchesThread = pending && typeof pending.toEntryId === "string" && typeof pending.toModelId === "string" && (pending.threadId === void 0 || pending.threadId === controller?.threadId);
+	const routeEntries = Array.isArray((state?.modelRoute)?.entries) ? (state?.modelRoute).entries ?? [] : [];
+	const entry = explicit ? explicit : pendingMatchesThread ? routeEntries.find((candidate) => candidate.id === pending.toEntryId && candidate.modelId === pending.toModelId) : routeEntries.find((candidate) => candidate.modelId === controller?.session?.modelId);
+	if (!entry || typeof entry.id !== "string" || typeof entry.modelId !== "string") return null;
+	const providerId = providerFromModelId(entry.modelId);
+	if (!providerId) return null;
+	return {
+		entryId: entry.id,
+		modelId: entry.modelId,
+		providerId,
+		...typeof entry.accountId === "string" ? { accountId: entry.accountId } : {}
+	};
+}
+/**
+* A14: `Automatic` rotation starts *at* the persisted active account and walks
+* insertion order from there, wrapping once. The active account is the cursor
+* rotation last left at, so a turn that starts at index 0 regardless would
+* re-activate and re-try an account the previous turn already moved past —
+* which is the whole job the removed sticky-exclusion set was doing badly.
+* With no persisted active account the order is plain insertion order.
+*/
+function orderAccountsFromActive(accounts, activeId) {
+	const index = activeId === void 0 ? -1 : accounts.findIndex((account) => account.id === activeId);
+	if (index <= 0) return accounts;
+	return [...accounts.slice(index), ...accounts.slice(0, index)];
+}
+async function applyPreferredAccountRoute(args, store, route) {
+	store.reload();
+	const preferredId = getRouteTargetAccountId(route);
+	const accounts = store.listAccounts?.(route.providerId) ?? [];
+	if (accounts.length === 0 && preferredId === void 0) return false;
+	const tried = getTriedInstances(args.state);
+	const unavailable = new Set(accounts.filter((account) => tried.has(account.id)).map((account) => account.id));
+	const active = getRequestActiveAccount(args, store, route.providerId) ?? store.getActiveAccount?.(route.providerId);
+	const selected = (preferredId ? accounts.filter((account) => account.id === preferredId) : orderAccountsFromActive(accounts, active?.id)).find((account) => !unavailable.has(account.id));
+	for (const accountId of unavailable) tried.add(accountId);
+	if (!selected) {
+		markRequestAccountRoutingExhausted(args.requestContext, route.providerId);
+		return false;
+	}
+	if (active?.id === selected.id) {
+		setRequestAccountSelection(args.requestContext, route.providerId, selected.id);
+		return false;
+	}
+	const activated = store.activateAccount ? store.activateAccount(route.providerId, selected.id) : selected;
+	if (!activated) {
+		if (preferredId !== void 0) markRequestAccountRoutingExhausted(args.requestContext, route.providerId);
+		return false;
+	}
+	setRequestAccountSelection(args.requestContext, route.providerId, activated.id);
+	if (preferredId === void 0) await emitAccountSwitchPart(args, {
+		provider: route.providerId,
+		from: active ? {
+			id: active.id,
+			label: active.label
+		} : null,
+		to: {
+			id: activated.id,
+			label: activated.label
+		},
+		reason: "preferred-routing",
+		at: (/* @__PURE__ */ new Date()).toISOString()
+	});
+	return true;
+}
+var AccountRotationProcessor = class {
+	options;
+	id = "mastracode-account-rotation";
+	constructor(options) {
+		this.options = options;
+	}
+	async processAPIError(args) {
+		const { error, state } = args;
+		if (args.retryCount >= this.options.maxProcessorRetries) {
+			await this.gateChainHop(args, error);
+			return { retry: false };
+		}
+		const classification = classifyRotationError(error);
+		if (classification.kind === "never") {
+			await this.gateChainHop(args, error);
+			return { retry: false };
+		}
+		const cascade = await this.getModelRouteCascade(args);
+		const currentEntry = cascade?.entries[cascade.position];
+		const providerId = providerFromError(error) ?? (currentEntry ? providerFromModelId(currentEntry.modelId) : void 0) ?? (cascade ? void 0 : providerFromSession(args));
+		if (!providerId) {
+			await this.emitModelFallbackPart(args, classification.kind === "hop" ? "persistent-outage" : "pool-exhausted");
+			return { retry: false };
+		}
+		const store = resolveCredentialStore(args.requestContext) ?? this.options.credentialStore;
+		store.reload();
+		const accounts = store.listAccounts?.(providerId) ?? [];
+		const active = getRequestActiveAccount(args, store, providerId);
+		const route = currentEntry ? resolveAccountRoute(args, currentEntry) : resolveAccountRoute(args);
+		if (classification.kind === "rotate" && classification.reason === "auth-failed" && active) {
+			const forced = getForcedRefreshInstances(state);
+			const refreshKey = `${providerId}:${active?.id ?? "active"}`;
+			if (!forced.has(refreshKey) && typeof store.forceRefreshActiveAccount === "function") {
+				forced.add(refreshKey);
+				if (await store.forceRefreshActiveAccount(providerId, active?.id) !== void 0) return { retry: true };
+			}
+		}
+		const targetAccountId = route?.providerId === providerId ? getRouteTargetAccountId(route) : void 0;
+		if (classification.kind === "hop") return this.declarePoolUnavailable(args, providerId, "persistent-outage", targetAccountId !== void 0);
+		if (targetAccountId !== void 0) return this.declarePoolUnavailable(args, providerId, "pool-exhausted", true);
+		const tried = getTriedInstances(state);
+		if (active) tried.add(active.id);
+		if (accounts.filter((account) => tried.has(account.id)).length >= accounts.length) return this.declarePoolUnavailable(args, providerId, "pool-exhausted");
+		const nextCandidate = (active ? accounts : orderAccountsFromActive(accounts, store.getActiveAccount?.(providerId)?.id)).find((account) => !tried.has(account.id));
+		const next = nextCandidate ? store.activateAccount?.(providerId, nextCandidate.id) : void 0;
+		if (!next) return this.declarePoolUnavailable(args, providerId, "pool-exhausted");
+		setRequestAccountSelection(args.requestContext, providerId, next.id);
+		tried.add(next.id);
+		args.rotateResponseMessageId?.();
+		await emitAccountSwitchPart(args, {
+			provider: providerId,
+			from: active ? {
+				id: active.id,
+				label: active.label
+			} : null,
+			to: {
+				id: next.id,
+				label: next.label
+			},
+			reason: classification.reason,
+			at: (/* @__PURE__ */ new Date()).toISOString()
+		});
+		return { retry: true };
+	}
+	/**
+	* Resolve the request's host-supplied model route once and cache the reachable
+	* prefix in processor state. Resolution mirrors getDynamicModel so a hop is
+	* never announced for an entry core cannot reach.
+	*/
+	async getModelRouteCascade(args) {
+		if (args.state.modelRouteCascade !== void 0) return args.state.modelRouteCascade ?? null;
+		const controller = getRoutingController(args);
+		const state = controller?.getState?.();
+		const route = (state?.modelRoute)?.entries;
+		const pending = state?.mastracodePendingModelFallback;
+		const startIndex = pending && typeof pending.toEntryId === "string" && (pending.threadId === void 0 || pending.threadId === controller?.threadId) ? route?.findIndex((entry) => entry.id === pending.toEntryId) : route?.findIndex((entry) => entry.modelId === controller?.session?.modelId);
+		if (!route || startIndex === void 0 || startIndex < 0 || route.length - startIndex < 2) {
+			args.state.modelRouteCascade = null;
+			return null;
+		}
+		const thinkingLevel = resolveRequestThinkingLevel({
+			state: { thinkingLevel: state?.thinkingLevel },
+			...!this.options.modeless && { session: { modeId: typeof controller?.session?.modeId === "string" ? controller.session.modeId : "build" } }
+		}, this.options.settingsPath);
+		const entries = [];
+		for (const entry of route.slice(startIndex)) {
+			if (typeof entry.id !== "string" || entry.id.length === 0 || typeof entry.modelId !== "string" || entry.modelId.length === 0) break;
+			if (entries.length > 0) try {
+				resolveModel(entry.modelId, {
+					thinkingLevel,
+					remapForCodexOAuth: true,
+					requestContext: args.requestContext
+				});
+			} catch {
+				break;
+			}
+			entries.push({
+				id: entry.id,
+				label: typeof entry.label === "string" && entry.label.length > 0 ? entry.label : entry.id,
+				modelId: entry.modelId,
+				...typeof entry.accountId === "string" ? { accountId: entry.accountId } : {}
+			});
+		}
+		if (entries.length < 2) {
+			args.state.modelRouteCascade = null;
+			return null;
+		}
+		const cascade = {
+			entries,
+			position: 0
+		};
+		args.state.modelRouteCascade = cascade;
+		return cascade;
+	}
+	/**
+	* Q14 gate: 400/unknown/unattributable errors never advance routes. Core's
+	* fallback array advances on ANY thrown error except TripWire
+	* (llm-execution-step.ts), so when the session route has another entry and the
+	* current entry is non-last, a bare `retry: false` would silently hop on an
+	* error class the user excluded from hop triggers. TripWire is the only
+	* no-advance escape: the runner rethrows it and the fallback loop declines
+	* to advance. No chain (or already on the last entry) → return and let the
+	* plain `retry: false` surface the error exactly as before.
+	*/
+	async gateChainHop(args, error) {
+		const cascade = await this.getModelRouteCascade(args);
+		if (!cascade) return;
+		if (cascade.position >= cascade.entries.length - 1) return;
+		throw new TripWire(error instanceof Error ? error.message : String(error), {}, this.id);
+	}
+	/** Announce and persist the next model-route hop before core advances. */
+	async emitModelFallbackPart(args, reason) {
+		const cascade = await this.getModelRouteCascade(args);
+		if (!cascade) return;
+		const from = cascade.entries[cascade.position];
+		const to = cascade.entries[cascade.position + 1];
+		if (!from || !to) return;
+		const controller = args.requestContext?.get("controller");
+		const at = (/* @__PURE__ */ new Date()).toISOString();
+		const threadId = typeof controller?.threadId === "string" ? controller.threadId : void 0;
+		const pending = {
+			fromEntryId: from.id,
+			toEntryId: to.id,
+			toModelId: to.modelId,
+			...threadId ? { threadId } : {},
+			reason,
+			at
+		};
+		await controller?.setThreadSetting?.({
+			key: MODEL_FALLBACK_STATE_KEY,
+			value: pending
+		});
+		const data = {
+			from: {
+				entryId: from.id,
+				label: from.label
+			},
+			to: {
+				entryId: to.id,
+				label: to.label
+			},
+			reason,
+			at
+		};
+		try {
+			await args.writer?.custom({
+				type: MODEL_FALLBACK_PART_TYPE,
+				data
+			});
+		} catch (error) {
+			await controller?.setThreadSetting?.({
+				key: MODEL_FALLBACK_STATE_KEY,
+				value: void 0
+			});
+			throw error;
+		}
+		await controller?.setState?.({ [MODEL_FALLBACK_STATE_KEY]: pending });
+		args.state.startNoticeEmitted = false;
+		const targetRoute = resolveAccountRoute(args, to);
+		if (targetRoute) await applyPreferredAccountRoute(args, resolveCredentialStore(args.requestContext) ?? this.options.credentialStore, targetRoute).catch(() => void 0);
+		controller?.emitEvent?.({
+			type: "info",
+			message: modelFallbackNoticeText(data)
+		});
+		cascade.position++;
+	}
+	/**
+	* Pool done for this request: every instance recorded in the tried-set and
+	* a `to: null` part emitted. Returns `retry: false` so core's fallback
+	* array can hop to the next route entry (announced by `emitModelFallbackPart`).
+	* Silent on the account part when the provider has no registry at all —
+	* there are no accounts to declare unavailable, but the hop still applies.
+	*/
+	async declarePoolUnavailable(args, providerId, reason, exclusive = false) {
+		const store = resolveCredentialStore(args.requestContext) ?? this.options.credentialStore;
+		const accounts = store.listAccounts?.(providerId) ?? [];
+		if (accounts.length === 0) {
+			await this.emitModelFallbackPart(args, reason);
+			return { retry: false };
+		}
+		const tried = getTriedInstances(args.state);
+		for (const account of accounts) tried.add(account.id);
+		const active = getRequestActiveAccount(args, store, providerId);
+		await emitAccountSwitchPart(args, {
+			provider: providerId,
+			from: active ? {
+				id: active.id,
+				label: active.label
+			} : null,
+			to: null,
+			reason,
+			at: (/* @__PURE__ */ new Date()).toISOString(),
+			...exclusive ? { exclusive: true } : {}
+		});
+		await this.emitModelFallbackPart(args, reason);
+		return { retry: false };
+	}
+};
+/**
+* Applies the pack's preferred account route once per request, before the
+* first model call. Without a route it only reloads the credential store so
+* the request sees accounts changed by other processes.
+*
+* TYPE CONSTRAINT: this class must NEVER implement `processAPIError`. It
+* lives in `inputProcessors`; the runner walks input processors first when
+* running `processAPIError`, so adding the method here would classify and
+* rotate errors BEFORE `StreamErrorRetryProcessor`'s transient retries run.
+*/
+var AccountStartNoticeProcessor = class {
+	options;
+	id = "mastracode-account-start-notice";
+	constructor(options) {
+		this.options = options;
+	}
+	async processInput(args) {
+		if (args.state.startNoticeEmitted) return args.messageList;
+		const store = resolveCredentialStore(args.requestContext) ?? this.options.credentialStore;
+		const route = resolveAccountRoute(args);
+		if (!route) {
+			store.reload();
+			return args.messageList;
+		}
+		if (await applyPreferredAccountRoute(args, store, route) || getRouteTargetAccountId(route) !== void 0) args.state.startNoticeEmitted = true;
+		return args.messageList;
+	}
+};
+//#endregion
+export { ACCOUNT_SWITCH_PART_TYPE, AccountRotationProcessor, AccountStartNoticeProcessor, MODEL_FALLBACK_PART_TYPE, MODEL_FALLBACK_STATE_KEY, PROVIDER_DISPLAY_NAMES, accountSwitchNoticeText, classifyRotationError, isAccountSwitchReason, isModelFallbackReason, modelFallbackNoticeText, providerFromError, providerFromModelId };
+
+//# sourceMappingURL=account-rotation-processor.js.map