@oh-my-pi/pi-ai 17.2.12 → 17.2.13

package/src/registry/oauth/callback-server.ts

@@ -17,6 +17,15 @@ import type { OAuthController, OAuthCredentials } from "./types";
 const DEFAULT_TIMEOUT = 300_000;
 const DEFAULT_HOSTNAME = "localhost";
 const CALLBACK_PATH = "/callback";
+const IPV4_LOOPBACK = "127.0.0.1";
+const IPV6_LOOPBACK = "::1";
+/**
+ * How many times a random-port bind may be redrawn when the ephemeral port it
+ * landed on is already held on {@link IPV6_LOOPBACK} by that exact address.
+ * Small on purpose: each redraw picks a fresh port, so a repeat collision is
+ * vanishingly unlikely.
+ */
+const IPV6_COMPANION_ATTEMPTS = 4;
 /**
  * Path served by {@link OAuthCallbackFlow} that 302-redirects to the pending
  * authorization URL. Kept out of {@link OAuthCallbackFlowOptions} because it
@@ -28,6 +37,27 @@ const LAUNCH_PATH = "/launch";
 
 export type CallbackResult = { code: string; state: string };
 
+/**
+ * Subset of {@link Bun.Server} this flow depends on, so a `localhost` flow can
+ * hand back one listener per loopback address family while still looking like a
+ * single server to callers.
+ */
+interface CallbackServer {
+	readonly port: Bun.Server<unknown>["port"];
+	stop: Bun.Server<unknown>["stop"];
+}
+
+/**
+ * Whether a failed bind means "another process already holds this port".
+ * Bun surfaces `EADDRINUSE` on the error's `code` where the platform reports
+ * it, and otherwise only in the message, so both are checked.
+ */
+function isAddressInUse(error: unknown): boolean {
+	const code = (error as { code?: unknown } | null | undefined)?.code;
+	if (typeof code === "string") return code === "EADDRINUSE";
+	return error instanceof Error && /EADDRINUSE|in use/i.test(error.message);
+}
+
 export interface OAuthCallbackFlowOptions {
 	preferredPort: number;
 	callbackPath?: string;
@@ -192,7 +222,7 @@ export abstract class OAuthCallbackFlow {
 	 */
 	async #startCallbackServer(
 		expectedState: string,
-	): Promise<{ server: Bun.Server<unknown>; redirectUri: string; launchUrl: string | undefined }> {
+	): Promise<{ server: CallbackServer; redirectUri: string; launchUrl: string | undefined }> {
 		try {
 			const server = this.#createServer(this.preferredPort, expectedState);
 			// `preferredPort: 0` opts into a random port — read the actual bound
@@ -233,7 +263,7 @@ export abstract class OAuthCallbackFlow {
 	 * but every callback flow uses TCP; a missing port here indicates a
 	 * configuration error rather than a fallback case.
 	 */
-	#resolveServerPort(server: Bun.Server<unknown>): number {
+	#resolveServerPort(server: CallbackServer): number {
 		const port = server.port;
 		if (typeof port !== "number") {
 			throw new AIError.ConfigurationError(
@@ -277,10 +307,68 @@ export abstract class OAuthCallbackFlow {
 	}
 
 	/**
-	 * Create HTTP server for OAuth callback.
+	 * Create the HTTP listener(s) for the OAuth callback.
+	 *
+	 * `localhost` is not a single endpoint: it resolves to both
+	 * {@link IPV4_LOOPBACK} and {@link IPV6_LOOPBACK}, and clients commonly try
+	 * `::1` first. Binding only the IPv4 literal hands the authorization code to
+	 * whatever holds the IPv6 loopback on the same port — a dev server on
+	 * `*:3000` is the common case — which answers from its own routes while this
+	 * flow waits out the full {@link DEFAULT_TIMEOUT}. Nothing detects it either:
+	 * a specific-address bind coexists with another process's wildcard bind, so
+	 * `Bun.serve` reports the port as free and the random-port fallback in
+	 * {@link #startCallbackServer} never runs.
+	 *
+	 * Binding both loopback literals fixes the delivery rather than dodging it:
+	 * the kernel routes a connection to the most specific matching bind, so our
+	 * `::1` listener receives `localhost` traffic that would otherwise reach a
+	 * process bound to the `::` wildcard. Both listeners answer the same routes,
+	 * so which family the client resolves stops mattering.
+	 *
+	 * A genuine collision — another process on exactly this loopback address and
+	 * port — still raises EADDRINUSE and reaches the caller's in-use policy. A
+	 * host that cannot bind `::1` at all (IPv6 disabled, address unavailable) is
+	 * not a collision: the IPv4 listener is the only reachable endpoint there, so
+	 * it serves alone.
 	 */
-	#createServer(port: number, expectedState: string): Bun.Server<unknown> {
-		const hostname = this.callbackHostname === DEFAULT_HOSTNAME ? "127.0.0.1" : this.callbackHostname;
+	#createServer(port: number, expectedState: string): CallbackServer {
+		if (this.callbackHostname !== DEFAULT_HOSTNAME) {
+			return this.#serve(this.callbackHostname, port, expectedState);
+		}
+		for (let attempt = 0; ; attempt++) {
+			const primary = this.#serve(IPV4_LOOPBACK, port, expectedState);
+			const boundPort = primary.port;
+			// A non-TCP endpoint has no port for the companion to target;
+			// #resolveServerPort reports that case precisely.
+			if (typeof boundPort !== "number") return primary;
+			let companion: Bun.Server<unknown>;
+			try {
+				companion = this.#serve(IPV6_LOOPBACK, boundPort, expectedState);
+			} catch (cause) {
+				if (!isAddressInUse(cause)) return primary;
+				void primary.stop(true);
+				// A pinned port has no alternative, so surface it as in use and let
+				// the caller apply its fallback or diagnostic policy. A random port
+				// can just be redrawn, since only that one number clashed.
+				if (port !== 0 || attempt >= IPV6_COMPANION_ATTEMPTS) throw cause;
+				continue;
+			}
+			// One server to callers. The IPv4 listener stays authoritative for
+			// `port` because the companion was bound to the port it resolved.
+			return {
+				get port() {
+					return primary.port;
+				},
+				stop: (closeActiveConnections?: boolean) => {
+					void companion.stop(closeActiveConnections);
+					return primary.stop(closeActiveConnections);
+				},
+			};
+		}
+	}
+
+	/** Bind one loopback listener serving the callback and launch routes. */
+	#serve(hostname: string, port: number, expectedState: string): Bun.Server<unknown> {
 		return Bun.serve({
 			hostname,
 			port,

package/src/stream.ts

@@ -1508,6 +1508,7 @@ function mapOptionsForApi<TApi extends Api>(
 		execHandlers: options?.execHandlers,
 		fetch: options?.fetch,
 		fallbacks: options?.fallbacks,
+		acceptEmptyResponse: options?.acceptEmptyResponse,
 		...simpleProviderOptions,
 	};
 

package/src/types.ts

@@ -552,6 +552,13 @@ export interface StreamOptions {
 	 * Optional retry delay hook for tests and transports that need custom scheduling.
 	 */
 	providerRetryWait?: (delayMs: number, signal?: AbortSignal) => Promise<void>;
+	/**
+	 * Accept a Google `STOP` response with no visible text or tool call as a
+	 * successful completion. Passive callers such as advisors use this because
+	 * silence is a valid result; interactive agent turns retain empty-response
+	 * retries by default. Ignored by non-Google providers.
+	 */
+	acceptEmptyResponse?: boolean;
 	/**
 	 * Optional `fetch` implementation override. Providers route every HTTP
 	 * request — direct calls, SDK clients, and retry helpers — through this

package/src/usage/cursor.ts

@@ -73,44 +73,145 @@ function deriveResetsAt(payload: Record<string, unknown>): number | undefined {
 	return undefined;
 }
 
-export function parseCursorIndividualUsage(payload: unknown, fetchedAt = Date.now()): UsageReport | null {
-	if (!isRecord(payload) || !isRecord(payload.individualUsage) || !isRecord(payload.individualUsage.overall)) {
-		return null;
-	}
-	const individual = payload.individualUsage.overall;
-	if (individual.enabled === false) return null;
+/**
+ * Parse a Cursor cents bucket (`used`/`limit`/`remaining` in USD cents).
+ * Returns null for disabled or non-positive / malformed buckets.
+ */
+function parseCursorCentsBucket(bucket: Record<string, unknown>): UsageAmount | null {
+	if (bucket.enabled === false) return null;
 
-	const reportedUsed = toNumber(individual.used);
-	const reportedRemaining = toNumber(individual.remaining);
+	const reportedUsed = toNumber(bucket.used);
+	const reportedRemaining = toNumber(bucket.remaining);
 	const hasValidUsed = reportedUsed !== undefined && reportedUsed >= 0;
 	const hasValidRemaining = reportedRemaining !== undefined && reportedRemaining >= 0;
-	const limit = toNumber(individual.limit);
+	const limit = toNumber(bucket.limit);
 
-	let amount: UsageAmount;
-	if (individual.limit === null || individual.limit === undefined) {
+	if (bucket.limit === null || bucket.limit === undefined) {
 		if (!hasValidUsed) return null;
-		amount = { used: reportedUsed / 100, unit: "usd" };
+		return { used: reportedUsed / 100, unit: "usd" };
+	}
+
+	if (limit === undefined || limit <= 0) return null;
+	let used: number;
+	if (reportedUsed !== undefined && reportedUsed > 0) {
+		used = reportedUsed;
+	} else if (hasValidRemaining && reportedRemaining < limit) {
+		used = Math.max(0, limit - reportedRemaining);
+	} else if (hasValidUsed) {
+		used = reportedUsed;
 	} else {
-		if (limit === undefined || limit <= 0) return null;
-		let used: number;
-		if (reportedUsed !== undefined && reportedUsed > 0) {
-			used = reportedUsed;
-		} else if (hasValidRemaining && reportedRemaining < limit) {
-			used = Math.max(0, limit - reportedRemaining);
-		} else if (hasValidUsed) {
-			used = reportedUsed;
+		return null;
+	}
+	const remaining = Math.max(0, limit - used);
+	return {
+		used: used / 100,
+		limit: limit / 100,
+		remaining: remaining / 100,
+		usedFraction: used / limit,
+		remainingFraction: remaining / limit,
+		unit: "usd",
+	};
+}
+
+/**
+ * Cursor's dashboard does not treat plan.used / plan.limit as the visible %.
+ * Pro+ shows separate quota pools (not one shared percent):
+ * - Cursor Models  ← autoPercentUsed
+ *   (includes Cursor Grok 4.5 and Composer 2.5)
+ * - Other Models   ← apiPercentUsed (separate included-$ pool; different quota)
+ * Prefer those fractions when present; fall back to cents only for older overall buckets.
+ */
+function parseCursorPlanDashboardAmounts(bucket: Record<string, unknown>): {
+	auto?: UsageAmount;
+	api?: UsageAmount;
+	fallback?: UsageAmount;
+} {
+	if (bucket.enabled === false) return {};
+
+	const limitCents = toNumber(bucket.limit);
+	const limitUsd = limitCents !== undefined && limitCents > 0 ? limitCents / 100 : undefined;
+	const autoPct = toNumber(bucket.autoPercentUsed);
+	const apiPct = toNumber(bucket.apiPercentUsed);
+	const totalPct = toNumber(bucket.totalPercentUsed);
+
+	const fromPercent = (pct: number, withLimit: boolean): UsageAmount => {
+		const usedFraction = Math.max(0, pct) / 100;
+		if (withLimit && limitUsd !== undefined) {
+			const used = limitUsd * usedFraction;
+			return {
+				used,
+				limit: limitUsd,
+				remaining: Math.max(0, limitUsd - used),
+				usedFraction,
+				remainingFraction: Math.max(0, 1 - usedFraction),
+				unit: "usd",
+			};
+		}
+		return { used: usedFraction * 100, usedFraction, unit: "percent" };
+	};
+
+	const result: { auto?: UsageAmount; api?: UsageAmount; fallback?: UsageAmount } = {};
+	if (autoPct !== undefined) result.auto = fromPercent(autoPct, false);
+	if (apiPct !== undefined) result.api = fromPercent(apiPct, true);
+	if (!result.auto && !result.api) {
+		if (totalPct !== undefined) {
+			result.fallback = fromPercent(totalPct, true);
 		} else {
-			return null;
+			const cents = parseCursorCentsBucket(bucket);
+			if (cents) result.fallback = cents;
 		}
-		const remaining = Math.max(0, limit - used);
-		amount = {
-			used: used / 100,
-			limit: limit / 100,
-			remaining: remaining / 100,
-			usedFraction: used / limit,
-			remainingFraction: remaining / limit,
-			unit: "usd",
-		};
+	}
+	return result;
+}
+
+function pushCursorPlanRails(limits: UsageLimit[], bucket: Record<string, unknown>, window: UsageWindow): void {
+	const rails = parseCursorPlanDashboardAmounts(bucket);
+	if (rails.auto) {
+		limits.push({
+			id: "cursor:usd:individual-auto",
+			label: "Cursor Models",
+			scope: { provider: "cursor", windowId: window.id },
+			window,
+			amount: rails.auto,
+			...(rails.auto.usedFraction !== undefined ? { status: usageStatus(rails.auto.usedFraction) } : {}),
+		});
+	}
+	if (rails.api) {
+		limits.push({
+			id: "cursor:usd:individual-api",
+			label: "Other Models",
+			scope: { provider: "cursor", windowId: window.id },
+			window,
+			amount: rails.api,
+			...(rails.api.usedFraction !== undefined ? { status: usageStatus(rails.api.usedFraction) } : {}),
+		});
+	}
+	if (rails.fallback) {
+		limits.push({
+			id: "cursor:usd:individual-plan",
+			label: "Personal Usage",
+			scope: { provider: "cursor", windowId: window.id },
+			window,
+			amount: rails.fallback,
+			...(rails.fallback.usedFraction !== undefined ? { status: usageStatus(rails.fallback.usedFraction) } : {}),
+		});
+	}
+}
+
+/**
+ * Cursor's `/api/usage-summary` has shipped two personal-bucket shapes:
+ * - Enterprise/team dashboards historically exposed `individualUsage.overall`
+ * - Current Pro / Pro+ / Ultra dashboards expose `individualUsage.plan`
+ *   (plus optional `onDemand`)
+ *
+ * Prefer a *usable* overall bucket; if overall is absent/disabled/malformed,
+ * fall through to plan rails (`autoPercentUsed` / `apiPercentUsed`). Always
+ * consider on-demand afterward so a valid on-demand meter is not dropped when
+ * the included plan bucket is empty.
+ */
+export function parseCursorIndividualUsage(payload: unknown, fetchedAt = Date.now()): UsageReport | null {
+	if (!isRecord(payload) || !isRecord(payload.individualUsage)) {
+		return null;
 	}
 
 	const resetsAt = deriveResetsAt(payload);
@@ -119,21 +220,52 @@ export function parseCursorIndividualUsage(payload: unknown, fetchedAt = Date.no
 		label: "Monthly",
 		...(resetsAt !== undefined ? { resetsAt } : {}),
 	};
-	const limitEntry: UsageLimit = {
-		id: "cursor:usd:individual-overall",
-		label: "Personal Usage",
-		scope: {
-			provider: "cursor",
-			windowId: window.id,
-		},
-		window,
-		amount,
-		...(amount.usedFraction !== undefined ? { status: usageStatus(amount.usedFraction) } : {}),
-	};
+	const limits: UsageLimit[] = [];
+
+	const overall = isRecord(payload.individualUsage.overall) ? payload.individualUsage.overall : null;
+	const plan = isRecord(payload.individualUsage.plan) ? payload.individualUsage.plan : null;
+
+	// Prefer a usable overall bucket; if it is disabled/malformed, fall through to plan.
+	let usedOverall = false;
+	if (overall) {
+		const amount = parseCursorCentsBucket(overall);
+		if (amount) {
+			usedOverall = true;
+			limits.push({
+				id: "cursor:usd:individual-overall",
+				label: "Personal Usage",
+				scope: { provider: "cursor", windowId: window.id },
+				window,
+				amount,
+				...(amount.usedFraction !== undefined ? { status: usageStatus(amount.usedFraction) } : {}),
+			});
+		}
+	}
+	if (!usedOverall && plan) {
+		pushCursorPlanRails(limits, plan, window);
+	}
+
+	// Keep on-demand even when the included plan/overall bucket is absent or unusable.
+	if (isRecord(payload.individualUsage.onDemand)) {
+		const onDemandAmount = parseCursorCentsBucket(payload.individualUsage.onDemand);
+		if (onDemandAmount && onDemandAmount.limit !== undefined && onDemandAmount.limit > 0) {
+			limits.push({
+				id: "cursor:usd:individual-ondemand",
+				label: "On-Demand Usage",
+				scope: { provider: "cursor", windowId: window.id },
+				window,
+				amount: onDemandAmount,
+				...(onDemandAmount.usedFraction !== undefined ? { status: usageStatus(onDemandAmount.usedFraction) } : {}),
+			});
+		}
+	}
+
+	if (limits.length === 0) return null;
+
 	return {
 		provider: "cursor",
 		fetchedAt,
-		limits: [limitEntry],
+		limits,
 		raw: payload,
 	};
 }

package/src/usage/kimi.ts

@@ -77,6 +77,23 @@ function formatDurationLabel(duration: number, timeUnit: string): string | undef
 	return undefined;
 }
 
+const MINUTE_MS = 60_000;
+const HOUR_MS = 3_600_000;
+const DAY_MS = 86_400_000;
+
+/**
+ * Status-line and ranking consumers match on canonical window ids ("5h",
+ * "7d"), so derive the id from the reported span: the 300-minute burst window
+ * surfaces as "5h" instead of "300time_unit_minute". Mirrors the
+ * intervalWindowId convention in minimax-code.ts.
+ */
+function canonicalWindowId(durationMs: number): string {
+	if (durationMs > 0 && durationMs % DAY_MS === 0) return `${durationMs / DAY_MS}d`;
+	if (durationMs > 0 && durationMs % HOUR_MS === 0) return `${durationMs / HOUR_MS}h`;
+	const minutes = Math.round(durationMs / MINUTE_MS);
+	return minutes > 0 ? `${minutes}m` : "default";
+}
+
 function buildWindow(windowData: Record<string, unknown>, nowMs: number): UsageWindow | undefined {
 	const duration = toNumber(windowData.duration);
 	const timeUnit = typeof windowData.timeUnit === "string" ? windowData.timeUnit : "";
@@ -86,14 +103,15 @@ function buildWindow(windowData: Record<string, unknown>, nowMs: number): UsageW
 	if (duration === undefined && !label && !resetsAt) return undefined;
 	let durationMs: number | undefined;
 	if (duration !== undefined) {
-		if (timeUnit.toUpperCase().includes("MINUTE")) durationMs = duration * 60_000;
-		else if (timeUnit.toUpperCase().includes("HOUR")) durationMs = duration * 3_600_000;
-		else if (timeUnit.toUpperCase().includes("DAY")) durationMs = duration * 86_400_000;
+		if (timeUnit.toUpperCase().includes("MINUTE")) durationMs = duration * MINUTE_MS;
+		else if (timeUnit.toUpperCase().includes("HOUR")) durationMs = duration * HOUR_MS;
+		else if (timeUnit.toUpperCase().includes("DAY")) durationMs = duration * DAY_MS;
+		else if (timeUnit.toUpperCase().includes("WEEK")) durationMs = duration * 7 * DAY_MS;
 		else if (timeUnit.toUpperCase().includes("SECOND")) durationMs = duration * 1000;
 	}
 
 	return {
-		id: duration !== undefined && timeUnit ? `${duration}${timeUnit.toLowerCase()}` : "default",
+		id: durationMs !== undefined ? canonicalWindowId(durationMs) : "default",
 		label: label ?? "Usage window",
 		durationMs,
 		resetsAt,
@@ -177,7 +195,13 @@ function parseUsagePayload(payload: unknown, nowMs: number): { rows: KimiUsageRo
 
 	if (isRecord(data.usage)) {
 		const summary = buildUsageRow(data.usage, "Total quota", nowMs);
-		if (summary) rows.push(summary);
+		if (summary) {
+			// Kimi Code's aggregate quota resets weekly, but the payload carries
+			// only `resetTime` and no duration. Attach the canonical weekly
+			// window explicitly so status-line/ranking consumers recognize it.
+			summary.window = { id: "7d", label: "7 Day", resetsAt: summary.resetsAt };
+			rows.push(summary);
+		}
 	}
 
 	if (Array.isArray(data.limits)) {

package/src/usage/openai-codex-reset.ts

@@ -19,6 +19,7 @@
  * share one wire contract.
  */
 import { toNumber } from "@oh-my-pi/pi-catalog/utils";
+import { USER_AGENT } from "@oh-my-pi/pi-utils";
 import type { FetchImpl } from "../types";
 import { isRecord } from "../utils";
 import { normalizeCodexBaseUrl } from "./openai-codex-base-url";
@@ -89,7 +90,7 @@ function buildUrl(baseUrl: string | undefined, routePath: string): string {
 function buildHeaders(auth: CodexResetAuth, json: boolean): Record<string, string> {
 	const headers: Record<string, string> = {
 		Authorization: `Bearer ${auth.accessToken}`,
-		"User-Agent": "OpenCode-Status-Plugin/1.0",
+		"User-Agent": USER_AGENT,
 	};
 	if (auth.accountId) headers["ChatGPT-Account-Id"] = auth.accountId;
 	if (json) headers["Content-Type"] = "application/json";

package/src/usage/openai-codex.ts

@@ -1,5 +1,6 @@
 import { Buffer } from "node:buffer";
 import { toNumber } from "@oh-my-pi/pi-catalog/utils";
+import { USER_AGENT } from "@oh-my-pi/pi-utils";
 import type {
 	CredentialRankingContext,
 	CredentialRankingStrategy,
@@ -417,7 +418,7 @@ export const openaiCodexUsageProvider: UsageProvider = {
 
 		const headers: Record<string, string> = {
 			Authorization: `Bearer ${accessToken}`,
-			"User-Agent": "OpenCode-Status-Plugin/1.0",
+			"User-Agent": USER_AGENT,
 		};
 		if (accountId) {
 			headers["ChatGPT-Account-Id"] = accountId;

package/src/usage/zai.ts

@@ -1,4 +1,5 @@
 import { toNumber } from "@oh-my-pi/pi-catalog/utils";
+import { USER_AGENT } from "@oh-my-pi/pi-utils";
 import type {
 	CredentialRankingStrategy,
 	UsageAmount,
@@ -228,7 +229,7 @@ async function fetchZaiUsage(params: UsageFetchParams, ctx: UsageFetchContext):
 	const headers: Record<string, string> = {
 		Authorization: token,
 		"Content-Type": "application/json",
-		"User-Agent": "OpenCode-Status-Plugin/1.0",
+		"User-Agent": USER_AGENT,
 	};
 
 	let payload: ZaiQuotaPayload | null = null;

package/src/utils/aws-profile.ts

@@ -78,7 +78,45 @@ export function hasConfiguredAwsProfile(profile?: string): boolean {
 	const configPath = $env.AWS_CONFIG_FILE || path.join(os.homedir(), ".aws", "config");
 	const credentialsIni = readAwsIniSync(credentialsPath);
 	const configIni = shouldLoadAwsSharedConfig(profile) ? readAwsIniSync(configPath) : undefined;
-	const merged = { ...(configIni?.[selectedProfile] ?? {}), ...(credentialsIni?.[selectedProfile] ?? {}) };
+	return profileHasCredentialSource(selectedProfile, credentialsIni, configIni, new Set());
+}
+
+/**
+ * Whether a profile terminates in a usable credential source. Mirrors the
+ * resolver's per-profile dispatch (static keys, SSO, `credential_process`,
+ * `role_arn` chaining) so the availability probe never diverges from what
+ * `resolveAwsCredentials` can actually resolve. `role_arn` chains follow
+ * `source_profile` recursively (cycle-guarded by `seen`); MFA-gated roles are
+ * treated as unusable because non-interactive resolution cannot supply a token.
+ */
+function profileHasCredentialSource(
+	profile: string,
+	credentialsIni: AwsIniFile | undefined,
+	configIni: AwsIniFile | undefined,
+	seen: Set<string>,
+): boolean {
+	if (seen.has(profile)) return false;
+	seen.add(profile);
+	const merged = { ...(configIni?.[profile] ?? {}), ...(credentialsIni?.[profile] ?? {}) };
+	if (merged.role_arn) {
+		if (merged.web_identity_token_file) return true;
+		if (merged.mfa_serial) return false;
+		if (merged.credential_source) {
+			switch (merged.credential_source) {
+				case "Environment":
+					return !!($env.AWS_ACCESS_KEY_ID && $env.AWS_SECRET_ACCESS_KEY);
+				case "EcsContainer":
+					return !!($env.AWS_CONTAINER_CREDENTIALS_RELATIVE_URI || $env.AWS_CONTAINER_CREDENTIALS_FULL_URI);
+				case "Ec2InstanceMetadata":
+					return $env.AWS_EC2_METADATA_DISABLED?.toLowerCase() !== "true";
+				default:
+					return false;
+			}
+		}
+		if (merged.source_profile)
+			return profileHasCredentialSource(merged.source_profile, credentialsIni, configIni, seen);
+		return false;
+	}
 	if (merged.aws_access_key_id && merged.aws_secret_access_key) return true;
 	if (merged.credential_process) return true;
 	if (!merged.sso_account_id || !merged.sso_role_name) return false;

package/src/utils/block-symbols.ts

@@ -59,6 +59,24 @@ export const kCursorExecResolved = Symbol("provider.block.cursorExecResolved");
 /** Carries the resolved marker without exposing a string-keyed property. */
 export type CursorExecResolvedCarrier = object & { [kCursorExecResolved]?: true };
 
+/** True when a toolCall block was already executed by Cursor's exec channel. */
+export function isCursorExecResolved(block: CursorExecResolvedCarrier | null | undefined): boolean {
+	return block?.[kCursorExecResolved] === true;
+}
+
+/**
+ * Copy {@link kCursorExecResolved} onto a cloned/projected toolCall block.
+ *
+ * Stream projectors (owned/in-band dialect, leaked-thinking heal) rebuild
+ * toolCall objects field-by-field. Dropping this marker lets `agent-loop.ts`
+ * re-execute a call Cursor already settled — duplicate toolResults and a
+ * second bash/write/delete. Partial-JSON is already copied explicitly; this
+ * marker is the other load-bearing symbol that must survive the same way.
+ */
+export function copyCursorExecResolved(target: CursorExecResolvedCarrier, source: CursorExecResolvedCarrier): void {
+	if (source[kCursorExecResolved] === true) target[kCursorExecResolved] = true;
+}
+
 /**
  * Marks a text block synthesized by cross-model thinking demotion in
  * `transformMessages`. Converters that flatten adjacent text blocks into one

package/src/utils/leaked-thinking-stream.ts

@@ -36,6 +36,7 @@ import type {
 } from "../types";
 import {
 	clearStreamingPartialJson,
+	copyCursorExecResolved,
 	getStreamingPartialJson,
 	type StreamingPartialJsonCarrier,
 	setStreamingPartialJson,
@@ -49,6 +50,7 @@ function cloneToolCall(source: StreamingToolCall): StreamingToolCall {
 	const block: StreamingToolCall = { ...source, arguments: source.arguments };
 	const partialJson = getStreamingPartialJson(source);
 	if (partialJson !== undefined) setStreamingPartialJson(block, partialJson);
+	copyCursorExecResolved(block, source);
 	return block;
 }
 
@@ -57,6 +59,7 @@ function syncToolCall(target: StreamingToolCall, source: StreamingToolCall): voi
 	const partialJson = getStreamingPartialJson(source);
 	if (partialJson === undefined) clearStreamingPartialJson(target);
 	else setStreamingPartialJson(target, partialJson);
+	copyCursorExecResolved(target, source);
 }
 
 /**

package/src/utils/openrouter-headers.ts

@@ -1,10 +1,10 @@
-import packageJson from "../../package.json" with { type: "json" };
+import { USER_AGENT } from "@oh-my-pi/pi-utils";
 
 export function getOpenRouterHeaders(): Record<string, string> {
 	return {
-		"User-Agent": `Oh-My-Pi/${packageJson.version}`,
+		"User-Agent": USER_AGENT,
 		"HTTP-Referer": "https://omp.sh/",
-		"X-OpenRouter-Title": "Oh-My-Pi",
+		"X-OpenRouter-Title": "omp",
 		"X-OpenRouter-Categories": "cli-agent",
 		"X-OpenRouter-Cache": "true",
 		"X-OpenRouter-Cache-TTL": "3600",