@oh-my-pi/pi-ai 18.1.10 → 18.1.11

package/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 ## [Unreleased]
 
+## [18.1.11] - 2026-09-05
+
+### Fixed
+
+- GitHub Copilot sign-in now requests only basic profile access, restoring login for Enterprise organizations that reject repository, gist, and Codespaces permissions ([#10656](https://github.com/can1357/oh-my-pi/issues/10656)).
+
 ## [18.1.9] - 2026-09-04
 
 ### Added
@@ -27,6 +33,7 @@
 ### Fixed
 
 - Fixed DeepSeek-family Responses replay (e.g. opencode-go) rejecting a resumed thinking-mode turn with `400 The reasoning_text in the thinking mode must be passed back to the API` when compaction dropped the turn's reasoning; a non-empty placeholder is now synthesized instead of an empty `reasoning_text` ([#10690](https://github.com/can1357/oh-my-pi/issues/10690)).
+- Fixed pi-native streams treating a connection that closed before its terminal event as a successful empty response; incomplete streams and namespaced gateway 5xx failures now remain retryable.
 
 ## [18.1.6] - 2026-09-03
 
@@ -50,6 +57,7 @@
 - Anthropic and OpenRouter credit-exhaustion errors now automatically switch to a sibling account instead of stopping the turn with a retry hint.
 - Fixed OpenCode Go and Zen requests by including the required stable per-conversation session identification.
 - Improved Anthropic prompt caching so explicit cache breakpoints preserve reusable tools and system prompts when the message tail changes.
+- Anthropic and OpenRouter 402 credit-exhaustion errors ("would exceed your available credits", "Insufficient credits") now switch to a sibling account instead of stopping the turn with a retry hint.
 
 ## [18.1.5] - 2026-09-03
 

package/dist/types/auth-storage.d.ts

@@ -496,10 +496,40 @@ export { isDefinitiveOAuthFailure } from "./error/auth-classify.js";
  * multi-hour) retry-after when it is sooner. `retryAtMs` is `undefined` when
  * no sibling credentials exist at all, or when the session has no tracked
  * credential to rotate away from.
+ *
+ * `blockedUntilMs` (epoch ms) is the just-blocked credential's own unblock
+ * deadline — the later of the caller's retry-after and any exhausted window
+ * the usage report reveals. Callers that wait the account out (instead of
+ * rotating) must sleep until this, not the error-text hint alone.
+ *
+ * `priorBlockedUntilMs` (epoch ms) is the live block deadline the map already
+ * stored for this credential before this call. The merged `blockedUntilMs`
+ * masks a pre-existing block shorter than this call's own heuristic
+ * fallback (`Math.max` in the mark), so callers that replace that heuristic
+ * with an authoritative report window must consult the prior deadline to
+ * keep honoring the earlier response's provider-stated block.
+ *
+ * `priorBlockedUntilTimed` is `true` when that prior deadline came from
+ * provider-stated timing (a parsed hint or usage-report reset) rather than
+ * another session's heuristic guess — only timed priors may extend a wait
+ * past an authoritative report window. Persisted blocks carry no provenance
+ * and count as untimed: a stale persisted heuristic must not outrank a
+ * fresh complete report (longer persisted deadlines still win through the
+ * merged `blockedUntilMs`).
+ *
+ * `reportResetAtMs` (epoch ms) is present only when the usage report is a
+ * complete authority for the wait: every exhausted window carries a future
+ * reset, so sleeping until the latest one can actually clear the account. A
+ * permanent cap alongside a timed window (or no report at all) leaves it
+ * unset, and the heuristic fallback alone must never authorize a wait.
  */
 export interface UsageLimitMarkResult {
     switched: boolean;
     retryAtMs?: number;
+    blockedUntilMs?: number;
+    priorBlockedUntilMs?: number;
+    priorBlockedUntilTimed?: boolean;
+    reportResetAtMs?: number;
 }
 export type ModelUsageHealthState = "healthy" | "reserve" | "depleted" | "unknown";
 export interface ModelUsageAccountHealth {
@@ -1013,6 +1043,12 @@ export declare class AuthStorage {
      */
     markUsageLimitReached(provider: string, sessionId: string | undefined, options?: {
         retryAfterMs?: number;
+        /**
+         * Whether `retryAfterMs` came from provider-stated timing (a parsed
+         * retry hint) rather than a heuristic/default guess. A report reset
+         * extending the block counts as provider timing regardless.
+         */
+        providerTimed?: boolean;
         baseUrl?: string;
         modelId?: string;
         apiKey?: string;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@oh-my-pi/pi-ai",
-	"version": "18.1.10",
+	"version": "18.1.11",
 	"description": "Unified LLM API with automatic model discovery and provider configuration",
 	"keywords": [
 		"ai",
@@ -124,11 +124,11 @@
 		"fmt": "oxfmt --no-error-on-unmatched-pattern 'src/**/*.{ts,tsx}' '{test,bench,examples,scripts}/**/*.ts' '*.ts'"
 	},
 	"dependencies": {
-		"@oh-my-pi/omptype": "18.1.10",
-		"@oh-my-pi/pi-catalog": "18.1.10",
-		"@oh-my-pi/pi-natives": "18.1.10",
-		"@oh-my-pi/pi-utils": "18.1.10",
-		"@oh-my-pi/pi-wire": "18.1.10"
+		"@oh-my-pi/omptype": "18.1.11",
+		"@oh-my-pi/pi-catalog": "18.1.11",
+		"@oh-my-pi/pi-natives": "18.1.11",
+		"@oh-my-pi/pi-utils": "18.1.11",
+		"@oh-my-pi/pi-wire": "18.1.11"
 	},
 	"devDependencies": {
 		"@types/bun": "^1.3.14"

package/src/auth-gateway/server.ts

@@ -251,6 +251,7 @@ async function refreshGatewayApiKeyAfterAuthError(
 		const retryAfterMs = extractRetryHint(undefined, message);
 		const { switched, retryAtMs } = await storage.markUsageLimitReached(provider, sessionId, {
 			retryAfterMs,
+			providerTimed: retryAfterMs !== undefined,
 			baseUrl: model.baseUrl,
 			modelId: model.id,
 			apiKey: oldKey,

package/src/auth-storage.ts

@@ -755,10 +755,40 @@ export { isDefinitiveOAuthFailure } from "./error/auth-classify";
  * multi-hour) retry-after when it is sooner. `retryAtMs` is `undefined` when
  * no sibling credentials exist at all, or when the session has no tracked
  * credential to rotate away from.
+ *
+ * `blockedUntilMs` (epoch ms) is the just-blocked credential's own unblock
+ * deadline — the later of the caller's retry-after and any exhausted window
+ * the usage report reveals. Callers that wait the account out (instead of
+ * rotating) must sleep until this, not the error-text hint alone.
+ *
+ * `priorBlockedUntilMs` (epoch ms) is the live block deadline the map already
+ * stored for this credential before this call. The merged `blockedUntilMs`
+ * masks a pre-existing block shorter than this call's own heuristic
+ * fallback (`Math.max` in the mark), so callers that replace that heuristic
+ * with an authoritative report window must consult the prior deadline to
+ * keep honoring the earlier response's provider-stated block.
+ *
+ * `priorBlockedUntilTimed` is `true` when that prior deadline came from
+ * provider-stated timing (a parsed hint or usage-report reset) rather than
+ * another session's heuristic guess — only timed priors may extend a wait
+ * past an authoritative report window. Persisted blocks carry no provenance
+ * and count as untimed: a stale persisted heuristic must not outrank a
+ * fresh complete report (longer persisted deadlines still win through the
+ * merged `blockedUntilMs`).
+ *
+ * `reportResetAtMs` (epoch ms) is present only when the usage report is a
+ * complete authority for the wait: every exhausted window carries a future
+ * reset, so sleeping until the latest one can actually clear the account. A
+ * permanent cap alongside a timed window (or no report at all) leaves it
+ * unset, and the heuristic fallback alone must never authorize a wait.
  */
 export interface UsageLimitMarkResult {
 	switched: boolean;
 	retryAtMs?: number;
+	blockedUntilMs?: number;
+	priorBlockedUntilMs?: number;
+	priorBlockedUntilTimed?: boolean;
+	reportResetAtMs?: number;
 }
 
 export type ModelUsageHealthState = "healthy" | "reserve" | "depleted" | "unknown";
@@ -1325,6 +1355,14 @@ export class AuthStorage {
 	#oauthBearerFingerprints: Map<string, Map<number, string[]>> = new Map();
 	/** Maps provider:type -> credentialIndex -> blockedUntilMs for temporary backoff. */
 	#credentialBackoff: Map<string, Map<number, number>> = new Map();
+	/**
+	 * Provenance of each in-memory block: `true` when the deadline came from
+	 * provider-stated timing (a parsed retry hint or a usage-report reset),
+	 * `false` when it is a heuristic/default guess. Mirrors
+	 * {@link AuthStorage.#credentialBackoff} longest-wins semantics, tracking
+	 * the flag of whichever deadline currently wins.
+	 */
+	#credentialBackoffProviderTimed: Map<string, Map<number, boolean>> = new Map();
 	/** Earliest time a freshly-set in-memory block may be cleared by live usage reconciliation. */
 	#credentialBackoffProbeAfter: Map<string, Map<number, number>> = new Map();
 	/**
@@ -1800,6 +1838,10 @@ export class AuthStorage {
 			if (backoffMap.size === 0) {
 				this.#credentialBackoff.delete(backoffKey);
 			}
+			this.#credentialBackoffProviderTimed.get(backoffKey)?.delete(credentialIndex);
+			if (this.#credentialBackoffProviderTimed.get(backoffKey)?.size === 0) {
+				this.#credentialBackoffProviderTimed.delete(backoffKey);
+			}
 			const probeAfterMap = this.#credentialBackoffProbeAfter.get(backoffKey);
 			probeAfterMap?.delete(credentialIndex);
 			if (probeAfterMap?.size === 0) this.#credentialBackoffProbeAfter.delete(backoffKey);
@@ -1906,13 +1948,48 @@ export class AuthStorage {
 		return this.#getCredentialBlockedUntil(provider, providerKey, credentialIndex, blockScope) !== undefined;
 	}
 
-	/** Marks a credential as blocked until the specified time. */
+	/**
+	 * Whether the in-memory block currently sitting at exactly `deadline` for
+	 * this credential was written with provider-stated timing. Mirrors the
+	 * scope enumeration of {@link AuthStorage.#getCredentialBlockedUntil}.
+	 * A deadline with no matching in-memory entry came from the persisted
+	 * store, which carries no provenance — a stale persisted heuristic guess
+	 * (pre-restart hintless response) must not outrank a fresh complete usage
+	 * report, so persisted-only deadlines count as untimed. Persisted
+	 * deadlines longer than this call's own request still win through the
+	 * merged `blockedUntilMs` comparison, which needs no provenance.
+	 */
+	#isProviderTimedBlock(
+		providerKey: string,
+		blockScopeOrScopes: string | readonly string[] | undefined,
+		credentialIndex: number,
+		deadline: number,
+	): boolean {
+		const scopes = (
+			typeof blockScopeOrScopes === "string" ? [blockScopeOrScopes] : (blockScopeOrScopes ?? [])
+		).filter(scope => scope.length > 0);
+		for (const key of [providerKey, ...scopes.map(scope => this.#toScopedBackoffKey(providerKey, scope))]) {
+			const entry = this.#credentialBackoff.get(key)?.get(credentialIndex);
+			if (entry === undefined || entry !== deadline) continue;
+			if (this.#credentialBackoffProviderTimed.get(key)?.get(credentialIndex) === true) return true;
+		}
+		return false;
+	}
+
+	/**
+	 * Marks a credential as blocked until the specified time. `providerTimed`
+	 * records whether the requested deadline comes from provider-stated
+	 * timing (a parsed retry hint or a usage-report reset) rather than a
+	 * heuristic/default guess; the stored block keeps the provenance of
+	 * whichever deadline wins the longest-wins merge.
+	 */
 	#markCredentialBlocked(
 		provider: string,
 		providerKey: string,
 		credentialIndex: number,
 		blockedUntilMs: number,
 		blockScope: string | undefined = undefined,
+		providerTimed = false,
 	): void {
 		const backoffKey = this.#toScopedBackoffKey(providerKey, blockScope);
 		const backoffMap = this.#credentialBackoff.get(backoffKey) ?? new Map<number, number>();
@@ -1920,6 +1997,16 @@ export class AuthStorage {
 		const nextBlockedUntil = Math.max(existing, blockedUntilMs);
 		backoffMap.set(credentialIndex, nextBlockedUntil);
 		this.#credentialBackoff.set(backoffKey, backoffMap);
+		const timedMap = this.#credentialBackoffProviderTimed.get(backoffKey) ?? new Map<number, boolean>();
+		const existingTimed = timedMap.get(credentialIndex) ?? false;
+		const nextTimed =
+			blockedUntilMs > existing
+				? providerTimed
+				: blockedUntilMs === existing
+					? existingTimed || providerTimed
+					: existingTimed;
+		timedMap.set(credentialIndex, nextTimed);
+		this.#credentialBackoffProviderTimed.set(backoffKey, timedMap);
 		const probeAfterMap = this.#credentialBackoffProbeAfter.get(backoffKey) ?? new Map<number, number>();
 		probeAfterMap.set(credentialIndex, Math.min(nextBlockedUntil, Date.now() + USAGE_REPORT_TTL_MS));
 		this.#credentialBackoffProbeAfter.set(backoffKey, probeAfterMap);
@@ -2205,6 +2292,7 @@ export class AuthStorage {
 					selection.index,
 					blockedUntil,
 					args.blockScope,
+					resetAtMs !== undefined,
 				);
 				blocked = true;
 			}
@@ -2310,6 +2398,11 @@ export class AuthStorage {
 				this.#credentialBackoff.delete(key);
 			}
 		}
+		for (const key of this.#credentialBackoffProviderTimed.keys()) {
+			if (key.startsWith(`${provider}:`)) {
+				this.#credentialBackoffProviderTimed.delete(key);
+			}
+		}
 	}
 
 	/** Updates credential at index in-place (used for OAuth token refresh) */
@@ -4600,11 +4693,43 @@ export class AuthStorage {
 		targetIndex: number,
 		blockedUntil: number,
 		routing: CredentialBlockRouting,
+		providerTimed: boolean,
 	): UsageLimitMarkResult {
+		// Snapshot the live block deadline BEFORE this call's mark: the merged
+		// value below masks a pre-existing block shorter than this call's own
+		// request (longest-wins), and recovery that replaces this call's
+		// heuristic fallback with an authoritative report window still needs
+		// the prior response's provider-stated deadline.
+		const priorBlockedUntilMs =
+			targetIndex >= 0
+				? this.#getCredentialBlockedUntil(provider, routing.providerKey, targetIndex, routing.blockScope)
+				: undefined;
+		const priorBlockedUntilTimed =
+			targetIndex >= 0 && priorBlockedUntilMs !== undefined
+				? this.#isProviderTimedBlock(routing.providerKey, routing.blockScope, targetIndex, priorBlockedUntilMs)
+				: false;
 		if (targetIndex >= 0) {
-			this.#markCredentialBlocked(provider, routing.providerKey, targetIndex, blockedUntil, routing.blockScope);
+			this.#markCredentialBlocked(
+				provider,
+				routing.providerKey,
+				targetIndex,
+				blockedUntil,
+				routing.blockScope,
+				providerTimed,
+			);
 		}
 
+		// Report the merged deadline the block map actually stores, not this
+		// call's input: a sibling session may have established a longer block
+		// for the same credential (out-of-order usage-limit responses), and
+		// #markCredentialBlocked keeps the longest. Waiting on the shorter
+		// value would retry before the credential is actually usable.
+		const mergedBlockedUntil =
+			targetIndex >= 0
+				? (this.#getCredentialBlockedUntil(provider, routing.providerKey, targetIndex, routing.blockScope) ??
+					blockedUntil)
+				: blockedUntil;
+
 		const remainingCredentials = this.#getCredentialsForProvider(provider)
 			.map((credential, index) => ({ credential, index }))
 			.filter(
@@ -4622,10 +4747,22 @@ export class AuthStorage {
 				candidate.index,
 				routing.siblingBlockScopes,
 			);
-			if (candidateBlockedUntil === undefined) return { switched: true };
+			if (candidateBlockedUntil === undefined)
+				return {
+					switched: true,
+					blockedUntilMs: mergedBlockedUntil,
+					priorBlockedUntilMs,
+					priorBlockedUntilTimed,
+				};
 			if (retryAtMs === undefined || candidateBlockedUntil < retryAtMs) retryAtMs = candidateBlockedUntil;
 		}
-		return { switched: false, retryAtMs };
+		return {
+			switched: false,
+			retryAtMs,
+			blockedUntilMs: mergedBlockedUntil,
+			priorBlockedUntilMs,
+			priorBlockedUntilTimed,
+		};
 	}
 
 	/**
@@ -4640,6 +4777,12 @@ export class AuthStorage {
 		sessionId: string | undefined,
 		options?: {
 			retryAfterMs?: number;
+			/**
+			 * Whether `retryAfterMs` came from provider-stated timing (a parsed
+			 * retry hint) rather than a heuristic/default guess. A report reset
+			 * extending the block counts as provider timing regardless.
+			 */
+			providerTimed?: boolean;
 			baseUrl?: string;
 			modelId?: string;
 			apiKey?: string;
@@ -4673,7 +4816,17 @@ export class AuthStorage {
 		const routing = this.#credentialBlockRouting(provider, credentialType, options?.modelId);
 		const now = Date.now();
 		let blockedUntil = now + (options?.retryAfterMs ?? AuthStorage.#defaultBackoffMs);
-
+		// Heuristic/default fallbacks are guesses; provider-stated hints and
+		// report-derived extensions are timed.
+		let providerTimed = options?.providerTimed === true;
+
+		// Epoch ms of the usage-report-derived reset. Authoritative only when
+		// EVERY exhausted window carries a future reset: a permanent cap
+		// alongside a timed window must not authorize a wait that can never
+		// clear it, and a bare heuristic must not sleep alone. Set
+		// independently of whether the report extends the hint so a shorter
+		// authoritative window still counts as provider timing.
+		let reportResetAtMs: number | undefined;
 		if (target && routing.strategy) {
 			const report = await raceUsageWithSignal(
 				this.#getUsageReport(provider, target.credential, options),
@@ -4685,6 +4838,15 @@ export class AuthStorage {
 					const resetAtMs = this.#getUsageResetAtMs(scopedLimits, Date.now());
 					if (resetAtMs && resetAtMs > blockedUntil) {
 						blockedUntil = resetAtMs;
+						providerTimed = true;
+					}
+					const nowMs = Date.now();
+					const exhaustedLimits = scopedLimits.filter(limit => this.#isUsageLimitExhausted(limit));
+					const futureResets = exhaustedLimits
+						.map(limit => this.#resolveWindowResetAt(limit.window))
+						.filter((reset): reset is number => reset !== undefined && reset > nowMs);
+					if (exhaustedLimits.length > 0 && futureResets.length === exhaustedLimits.length) {
+						reportResetAtMs = Math.max(...futureResets);
 					}
 				}
 			}
@@ -4696,7 +4858,15 @@ export class AuthStorage {
 		const targetIndex = this.#getStoredCredentials(provider).findIndex(
 			entry => entry.id === targetCredentialId && entry.credential.type === credentialType,
 		);
-		return this.#blockCredentialForRotation(provider, credentialType, targetIndex, blockedUntil, routing);
+		const rotation = this.#blockCredentialForRotation(
+			provider,
+			credentialType,
+			targetIndex,
+			blockedUntil,
+			routing,
+			providerTimed,
+		);
+		return reportResetAtMs === undefined ? rotation : { ...rotation, reportResetAtMs };
 	}
 
 	#resolveWindowResetAt(window: UsageLimit["window"]): number | undefined {
@@ -4906,6 +5076,7 @@ export class AuthStorage {
 					selection.index,
 					blockedUntil,
 					args.blockScope,
+					resetAtMs !== undefined,
 				);
 				blocked = true;
 			}
@@ -5562,6 +5733,7 @@ export class AuthStorage {
 						selection.index,
 						resetAtMs ?? Date.now() + AuthStorage.#defaultBackoffMs,
 						blockScope,
+						resetAtMs !== undefined,
 					);
 					return undefined;
 				}
@@ -5642,6 +5814,7 @@ export class AuthStorage {
 							selection.index,
 							resetAtMs ?? Date.now() + AuthStorage.#defaultBackoffMs,
 							blockScope,
+							resetAtMs !== undefined,
 						);
 						return undefined;
 					}
@@ -6335,6 +6508,11 @@ export class AuthStorage {
 			backoffMap.delete(index);
 			if (backoffMap.size === 0) this.#credentialBackoff.delete(key);
 		}
+		for (const [key, timedMap] of this.#credentialBackoffProviderTimed) {
+			if (key !== providerKey && !key.startsWith(scopedPrefix)) continue;
+			timedMap.delete(index);
+			if (timedMap.size === 0) this.#credentialBackoffProviderTimed.delete(key);
+		}
 		for (const [key, probeAfterMap] of this.#credentialBackoffProbeAfter) {
 			if (key !== providerKey && !key.startsWith(scopedPrefix)) continue;
 			probeAfterMap.delete(index);
@@ -6396,6 +6574,9 @@ export class AuthStorage {
 		const backoffMap = this.#credentialBackoff.get(key);
 		backoffMap?.delete(credentialIndex);
 		if (backoffMap?.size === 0) this.#credentialBackoff.delete(key);
+		const timedMap = this.#credentialBackoffProviderTimed.get(key);
+		timedMap?.delete(credentialIndex);
+		if (timedMap?.size === 0) this.#credentialBackoffProviderTimed.delete(key);
 		const probeAfterMap = this.#credentialBackoffProbeAfter.get(key);
 		probeAfterMap?.delete(credentialIndex);
 		if (probeAfterMap?.size === 0) this.#credentialBackoffProbeAfter.delete(key);
@@ -6687,6 +6868,7 @@ export class AuthStorage {
 			return (
 				await this.markUsageLimitReached(provider, sessionId, {
 					retryAfterMs,
+					providerTimed: retryAfterMs !== undefined,
 					modelId: options?.modelId,
 					apiKey: options?.apiKey,
 					credentialId: options?.credentialId,
@@ -6726,6 +6908,7 @@ export class AuthStorage {
 				sessionCredential.index,
 				Date.now() + AuthStorage.#defaultBackoffMs,
 				routing,
+				false,
 			).switched;
 		}
 

package/src/error/flags.ts

@@ -157,7 +157,7 @@ const TRANSIENT_ENVELOPE_PATTERN = /anthropic stream envelope error:/i;
 const TRANSIENT_ENVELOPE_TRUNCATION_PATTERN = /before message_(?:start|stop)/i;
 export const STREAM_READ_ERROR_PATTERN = /stream[_ -]?read[_ -]?error/i;
 export const TRANSIENT_TRANSPORT_PATTERN =
-	/\b(?:no[_ -]?capacity|(?:high|peak)[ _-]?demand|(?:at|over|insufficient)[ _-]?capacity|capacity[ _-]?(?:exceeded|exhausted)|peak[ _-]?load)\b|overloaded|provider.?returned.?error|rate.?limit|too many requests|\b(?:429|500|502|503|504)\b|service.?unavailable|server.?error|internal.?error|retry your request|network.?error|connection.?error|connection.?refused|unable.?to.?connect\.\s*is the computer able to access the url\?|other side closed|fetch failed|upstream.?connect|upstream.?request.?failed|reset before headers|socket hang up|timed? out|timeout|terminated|retry delay|stream stall|no error details in response|HTTP2(?:StreamReset|RefusedStream|EnhanceYourCalm)|nghttp2_(?:internal_error|refused_stream)|stream closed with error code nghttp2_(?:internal_error|refused_stream)|malformed.?function.?call/i;
+	/\b(?:no[_ -]?capacity|(?:high|peak)[ _-]?demand|(?:at|over|insufficient)[ _-]?capacity|capacity[ _-]?(?:exceeded|exhausted)|peak[ _-]?load)\b|overloaded|provider.?returned.?error|rate.?limit|too many requests|auth-gateway\s+5\d{2}(?=[:\s]|$)|\b(?:429|500|502|503|504)\b|service.?unavailable|server.?error|internal.?error|retry your request|network.?error|connection.?error|connection.?refused|unable.?to.?connect\.\s*is the computer able to access the url\?|other side closed|fetch failed|upstream.?connect|upstream.?request.?failed|reset before headers|socket hang up|timed? out|timeout|terminated|retry delay|stream stall|no error details in response|HTTP2(?:StreamReset|RefusedStream|EnhanceYourCalm)|nghttp2_(?:internal_error|refused_stream)|stream closed with error code nghttp2_(?:internal_error|refused_stream)|malformed.?function.?call/i;
 const AUTH_FAILURE_PATTERN =
 	/\b(?:401|403|unauthorized|forbidden|authentication|auth[_ ]?unavailable|no auth available|(?:invalid|no)[_ ]?api[_ ]?key)\b/i;
 const MALFORMED_FUNCTION_CALL_PATTERN = /\bmalformed.?function.?call\b/i;

package/src/providers/pi-native-client.ts

@@ -236,10 +236,6 @@ export function streamPiNative<TApi extends Api>(
 			}
 
 			if (!sawTerminal) {
-				// SSE closed before a terminal event reached us — synthesize one
-				// so awaiters of `.result()` resolve instead of hanging forever.
-				// Matches the gateway's own defensive fallback in
-				// `pi-native-server.encodeStream`.
 				const aborted = abortTracker.wasCallerAbort();
 				const partial = makeSyntheticAssistant(model as Model<Api>);
 				if (aborted) {
@@ -247,8 +243,16 @@ export function streamPiNative<TApi extends Api>(
 					partial.errorMessage = "stream closed without terminal event";
 					stream.push({ type: "error", reason: "aborted", error: partial });
 				} else {
-					partial.stopReason = "stop";
-					stream.push({ type: "done", reason: "stop", message: partial });
+					stream.fail(
+						new AIError.ProviderResponseError(
+							"pi-native stream read error: stream closed before a terminal response event",
+							{
+								provider: model.provider,
+								kind: "incomplete-stream",
+							},
+						),
+					);
+					return;
 				}
 			}
 			stream.end();

package/src/registry/oauth/github-copilot.ts

@@ -16,7 +16,7 @@ import type { FetchImpl } from "../../types";
 import type { OAuthController, OAuthCredentials } from "./types";
 
 const CLIENT_ID = "Ov23ctDVkRmgkPke0Mmm";
-const OAUTH_SCOPE = "read:user,read:org,repo,gist,codespace";
+const OAUTH_SCOPE = "read:user";
 const OAUTH_HEADERS = {
 	Accept: "application/json",
 	"Content-Type": "application/x-www-form-urlencoded",