oira666_pi-limits-wait 0.4.14 → 0.5.0

package/README.md

@@ -1,6 +1,6 @@
 # Pi Limits Wait
 
-[![npm](https://img.shields.io/npm/v/oira666_pi-limits-wait?style=flat-square&logo=npm&logoColor=white&label=npm&color=7c3aed)](https://www.npmjs.com/package/oira666_pi-limits-wait) [![node](https://img.shields.io/badge/node-%3E%3D18-7c3aed?style=flat-square&logo=nodedotjs&logoColor=white)](https://nodejs.org)
+[![npm](https://img.shields.io/npm/v/oira666_pi-limits-wait?style=flat-square&logo=npm&logoColor=white&label=npm&color=7c3aed)](https://www.npmjs.com/package/oira666_pi-limits-wait) [![node](https://img.shields.io/badge/node-%3E%3D22.19-7c3aed?style=flat-square&logo=nodedotjs&logoColor=white)](https://nodejs.org)
 
 Pi extension that keeps requests alive when a provider rate-limits you or returns `server_is_overloaded`.
 
@@ -14,16 +14,23 @@ Restart Pi or run `/reload` after installing.
 
 ## What it does
 
-- Works with all Pi model providers/APIs that use `streamSimple`.
+- Targets Pi 0.80.10+ and works with model providers that use `ModelRuntime.streamSimple`.
+- Intercepts the current runtime without registering synthetic providers; every retry and fallback re-enters Pi's normal provider/auth/base URL/configured-header composition, including OAuth refresh checks.
+- Reload-safe ownership ensures `/reload` transfers interception cleanly and aborts waits still owned by the previous extension instance. The interception has one process-global active extension owner, matching the interactive Pi CLI's single active session runtime lifecycle; SDK processes running multiple concurrent Pi sessions are not supported.
 - On rate-limit errors (`429`, `rate_limit`, `too many requests`, quota/reset messages), waits and retries in a loop.
-- Uses provider retry timing when available (`retry-after`, `retry-after-ms`, `retry in ...`, reset messages).
+- Uses provider retry timing when exposed through response callbacks or provider errors (`retry-after`, `retry-after-ms`, `retry in ...`, reset messages).
 - If no retry timing is available for a rate limit, waits 30 minutes before retrying.
 - On `server_is_overloaded`, waits 5 minutes, then retries. If the provider is still overloaded after Pi's normal retries, it waits another 5 minutes and repeats.
 - On transient network/transport failures — including undici idle-timeout aborts (`UND_ERR_HEADERS_TIMEOUT` / `UND_ERR_BODY_TIMEOUT`), `fetch failed`, `terminated`, `ECONNRESET`, `ETIMEDOUT`, etc. — treats the error as retryable with a short backoff (default 15s, or the provider's `retry-after`) instead of giving up. This prevents a stalled streaming request from turning into a silent hang.
 - For any other (unclassified) non-retryable error, retries the same model a few times (default 3) before falling back / freezing it, so a one-off hiccup does not immediately sideline a model.
 - Reports retry/fallback waits in chat notifications without adding persistent TUI status lines.
 - Press Enter during a retry wait to skip the wait and retry immediately.
-- Optionally falls back to configured models when the current/default model is rate-limited.
+- Optionally falls back to configured models when the current/default model is rate-limited. Every fallback to a different model—even on the same provider—deliberately discards request-owned credentials, headers, environment overrides, and provider-specific options so the target runtime resolves its own configuration.
+- Preserves Pi's `before_provider_request` / `after_provider_response` callback flow and sanitises only the exact Anthropic OAuth system-block shape generated by current Pi; Pi remains responsible for OAuth identity insertion.
+
+### Current runtime limitation
+
+Pi 0.80.10 does not expose a public factory for rebuilding the SDK's target-model-aware `transformHeaders` callback. Reusing the source request's closure on a fallback would apply source-model attribution and could leak extension-added headers, so limits-wait intentionally omits it for every different-model fallback. The target `ModelRuntime` still resolves target auth, base URL, configured provider/model headers, environment, and provider implementation canonically, but `before_provider_headers` cannot be re-fired for that fallback through the current public API.
 
 ## Optional fallback models
 
@@ -62,7 +69,7 @@ Each `fallback-models` entry supports:
 
 - `provider` — required. The Pi provider name, for example `anthropic`, `openai`, `google`, etc.
 - `modelname` — required. The model id/name as Pi knows it.
-- `reasoning effort` — optional. One of `off`, `minimal`, `low`, `medium`, `high`, `xhigh`. If omitted, Pi's current/default reasoning level is used.
+- `reasoning effort` — optional. One of `off`, `minimal`, `low`, `medium`, `high`, `xhigh`, `max`. If omitted, Pi's current/default reasoning level is used.
 
 Fallback behavior:
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oira666_pi-limits-wait",
-  "version": "0.4.14",
+  "version": "0.5.0",
   "description": "Extension for PI that allows to automatically wait for limits to reset and retry the request",
   "type": "module",
   "license": "MIT",
@@ -11,7 +11,7 @@
     "LICENSE"
   ],
   "engines": {
-    "node": ">=18"
+    "node": ">=22.19.0"
   },
   "repository": {
     "type": "git",
@@ -37,12 +37,12 @@
   },
   "dependencies": {},
   "peerDependencies": {
-    "@mariozechner/pi-ai": "*",
-    "@mariozechner/pi-coding-agent": "*"
+    "@earendil-works/pi-ai": "^0.80.10",
+    "@earendil-works/pi-coding-agent": "^0.80.10"
   },
   "devDependencies": {
-    "@mariozechner/pi-ai": "^0.66.1",
-    "@mariozechner/pi-coding-agent": "^0.66.1",
+    "@earendil-works/pi-ai": "^0.80.10",
+    "@earendil-works/pi-coding-agent": "^0.80.10",
     "tsx": "^4.20.6",
     "typescript": "^5.9.3"
   }

package/src/constants.ts

@@ -3,13 +3,20 @@ export const CLAUDE_CODE_IDENTITY =
 
 export const PI_REMOVAL_ANCHORS = [
   "pi-coding-agent",
-  "@mariozechner/pi-coding-agent",
+  "@earendil-works/pi-coding-agent",
   "badlogic/pi-mono",
 ] as const;
 
 export const PI_IDENTITY_SENTENCE_PATTERN =
   /(?:^|\n)\s*You are pi\b[^.!?\n]*(?:[.!?](?=\s|$)|(?=\n|$))/gi;
 
+// Strips the host-harness identity clause pi prepends to its system prompt, e.g.
+// "You are an expert coding assistant operating inside pi, a coding agent harness."
+// The Claude Code identity block already establishes who the assistant is, so
+// leaving this clause in tells the model (and Anthropic) it is running inside pi.
+export const PI_HARNESS_IDENTITY_PATTERN =
+  /\s+operating inside pi,\s*a coding agent harness/gi;
+
 export const CLAUDE_CODE_IDENTITY_PATTERN =
   /(?:^|\n)\s*You are Claude Code, Anthropic's official CLI for Claude\.\s*/gi;
 

package/src/index.ts

@@ -1,10 +1,11 @@
-import type { ExtensionAPI, ExtensionContext } from "@mariozechner/pi-coding-agent";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { isInternalSyntheticModel } from "./models.js";
+import { sanitiseAnthropicPayloadSystem } from "./prompt.js";
 import { loadFallbackSettings } from "./settings.js";
-import { state } from "./state.js";
-import { registerWrappedApi } from "./stream.js";
+import { consumeExpectedModelSelection, state } from "./state.js";
+import { installModelRuntimeInterception } from "./stream.js";
 
-export { sanitiseSystemPrompt } from "./prompt.js";
+export { sanitiseAnthropicPayloadSystem, sanitiseSystemPrompt } from "./prompt.js";
 export {
   getRetryableError,
   isAuthenticationRefreshError,
@@ -23,27 +24,24 @@ export {
 export {
   __configureFallbackModelsForTests,
   __setNonRetryableTuningForTests,
+  installModelRuntimeInterception,
   streamWithLimitsRetry,
   streamWithRateLimitRetry,
 } from "./stream.js";
 export { freezingEnabled, waitForRateLimit, waitForRetry } from "./ui.js";
 export type { FallbackModel } from "./types.js";
 
-function registerContextApis(pi: ExtensionAPI, ctx: ExtensionContext): void {
-  for (const model of ctx.modelRegistry.getAll()) {
-    if (!isInternalSyntheticModel(model)) registerWrappedApi(pi, model.api);
-  }
-  if (ctx.model && !isInternalSyntheticModel(ctx.model)) registerWrappedApi(pi, ctx.model.api);
-}
-
 export default function (pi: ExtensionAPI) {
   state.extensionApi = pi;
+  const releaseInterception = installModelRuntimeInterception();
+
+  // Current pi-ai inserts the Claude Code identity as the first system block
+  // for Anthropic OAuth. Sanitise only that exact payload shape; authentication,
+  // identity insertion and all request composition remain owned by ModelRuntime.
+  pi.on("before_provider_request", (event) => sanitiseAnthropicPayloadSystem(event.payload));
 
   pi.on("model_select", (event) => {
-    if (state.suppressNextModelSelect) {
-      state.suppressNextModelSelect = false;
-      return;
-    }
+    if (consumeExpectedModelSelection(event.model)) return;
     if (isInternalSyntheticModel(event.model)) return;
     state.primaryModel = event.model;
     state.primaryThinkingLevel = pi.getThinkingLevel();
@@ -54,23 +52,20 @@ export default function (pi: ExtensionAPI) {
     if (!state.primaryModel && ctx.model && !isInternalSyntheticModel(ctx.model)) state.primaryModel = ctx.model;
     state.primaryThinkingLevel ??= pi.getThinkingLevel();
     loadFallbackSettings(ctx);
-
-    // Some extensions may register providers after this extension loads. Wrap
-    // any APIs that exist by the time an agent starts too.
-    registerContextApis(pi, ctx);
-
-    // Anthropic subscription/OAuth identity is applied per provider request in
-    // streamWithLimitsRetry(). Doing it there ensures every retry/fallback
-    // attempt gets the right prompt for its actual target model, while
-    // non-Anthropic providers never inherit the Claude Code identity.
   });
 
-  // Run once more after all before_agent_start handlers have completed and the
-  // agent loop is about to make its first provider request. This catches
-  // providers that another extension registered during before_agent_start after
-  // our handler had already run.
   pi.on("agent_start", (_event, ctx) => {
     state.sharedCtx = ctx;
-    registerContextApis(pi, ctx);
+  });
+
+  pi.on("session_shutdown", () => {
+    // An old extension instance must not disable or clear state owned by a
+    // newer /reload instance.
+    if (!releaseInterception()) return;
+    state.ambientStatusCleanup?.();
+    state.modelStatusCleanup?.();
+    state.expectedModelSelections.clear();
+    state.sharedCtx = undefined;
+    state.extensionApi = undefined;
   });
 }

package/src/models.ts

@@ -1,8 +1,6 @@
-import type { ExtensionContext } from "@mariozechner/pi-coding-agent";
-import type { Api, Model, SimpleStreamOptions } from "@mariozechner/pi-ai";
+import type { Api, Model } from "@earendil-works/pi-ai";
 import { DEFAULT_NON_RETRYABLE_FREEZE_MS } from "./constants.js";
-import { isRateLimitError, parseRetryDelayMs } from "./retry-errors.js";
-import { state } from "./state.js";
+import { expectModelSelection, state } from "./state.js";
 import type { FallbackModel, RetryableError } from "./types.js";
 import { formatErrorDetail, formatDuration, reasonLabel } from "./ui.js";
 
@@ -34,9 +32,14 @@ export function getPrimaryModel(current: Model<Api>): Model<Api> {
   return state.primaryModel ?? current;
 }
 
+export function configuredAttempt(model: Model<Api>): FallbackModel {
+  return state.fallbackModels.find((entry) => modelKey(entry.model) === modelKey(model))
+    ?? { model, reasoningEffort: state.primaryThinkingLevel };
+}
+
 export function candidateOrder(current: Model<Api>): FallbackModel[] {
   const primary = getPrimaryModel(current);
-  const order: FallbackModel[] = [{ model: primary, reasoningEffort: state.primaryThinkingLevel }];
+  const order: FallbackModel[] = [configuredAttempt(primary)];
   const seen = new Set([modelKey(primary)]);
   for (const entry of state.fallbackModels) {
     const key = modelKey(entry.model);
@@ -103,33 +106,6 @@ export function rememberNonRetryableFailure(model: Model<Api>, errorMessage: str
   ensureRateLimitedModelsStatus();
 }
 
-export function recentObservedHttpError(maxAgeMs = 60_000): string | undefined {
-  if (!state.lastObservedHttpError) return undefined;
-  if (Date.now() - state.lastObservedHttpError.at > maxAgeMs) return undefined;
-  return state.lastObservedHttpError.message;
-}
-
-export function recentObservedRateLimitError(maxAgeMs = 60_000): string | undefined {
-  const message = recentObservedHttpError(maxAgeMs);
-  return message && isRateLimitError(message) ? message : undefined;
-}
-
-export function errorMessageWithRecentHttpStatus(errorMessage: string): string {
-  const observed = recentObservedHttpError();
-  if (!observed || errorMessage.includes(observed)) return errorMessage;
-
-  // SDK errors often keep only "429 Too Many Requests" and drop the response
-  // headers. Keep the observed fetch response when it carries retry timing, so
-  // Claude subscription limits use their exact reset/retry time instead of the
-  // generic 30 minute fallback.
-  const currentHasRetryTiming = parseRetryDelayMs(errorMessage) !== undefined;
-  const observedHasRetryTiming = parseRetryDelayMs(observed) !== undefined;
-  if (!currentHasRetryTiming && observedHasRetryTiming) return `${observed}; Error: ${errorMessage}`;
-
-  if (/(?:^|\D)[1-5]\d\d(?:\D|$)/.test(errorMessage)) return errorMessage;
-  return `${observed}; Error: ${errorMessage}`;
-}
-
 export function earliestCandidateDeadline(current: Model<Api>): number | undefined {
   const deadlines = candidateOrder(current)
     .map((entry) => activeLimit(entry.model)?.deadline ?? activeNonRetryableFailure(entry.model)?.deadline)
@@ -138,45 +114,42 @@ export function earliestCandidateDeadline(current: Model<Api>): number | undefin
 }
 
 export function initialAttempt(model: Model<Api>): FallbackModel {
-  const configured = state.fallbackModels.find((entry) => modelKey(entry.model) === modelKey(model));
-  const current = configured ?? { model, reasoningEffort: state.primaryThinkingLevel };
+  const current = configuredAttempt(model);
   if (!fallbackEnabled() || (!activeLimit(model) && !hasNonRetryableFailure(model))) return current;
   return nextAvailableCandidate(model) ?? current;
 }
 
-export async function optionsForModel(
-  originalModel: Model<Api>,
-  target: FallbackModel,
-  options?: SimpleStreamOptions,
-  ctx: ExtensionContext | undefined = state.sharedCtx,
-): Promise<SimpleStreamOptions | undefined> {
-  const level = target.reasoningEffort ?? state.primaryThinkingLevel;
-  const reasoning = level && level !== "off" ? level : undefined;
-  if (modelKey(originalModel) === modelKey(target.model)) {
-    return reasoning ? { ...options, reasoning } : options;
-  }
-  const auth = await ctx?.modelRegistry.getApiKeyAndHeaders(target.model);
-  if (!auth?.ok) throw new Error(auth ? auth.error : "Model registry is unavailable.");
-  return {
-    ...options,
-    ...(reasoning ? { reasoning } : {}),
-    apiKey: auth.apiKey,
-    headers: auth.headers || options?.headers ? { ...auth.headers, ...options?.headers } : undefined,
-  } as SimpleStreamOptions;
-}
-
-export async function switchPiModel(entry: FallbackModel): Promise<void> {
-  const pi = state.extensionApi;
-  if (!pi) return;
-  const current = state.sharedCtx?.model;
-  if (current && modelKey(current) === modelKey(entry.model)) return;
-  state.suppressNextModelSelect = true;
-  const ok = await pi.setModel(entry.model);
-  if (!ok) {
-    state.suppressNextModelSelect = false;
-    return;
-  }
-  const level = entry.reasoningEffort ?? state.primaryThinkingLevel;
-  if (level) pi.setThinkingLevel(level);
-  state.sharedCtx?.ui.notify(`Switched to ${formatModel(entry.model)}${level ? ` (${level})` : ""}.`, "info");
+let modelSwitchQueue = Promise.resolve();
+
+export async function switchPiModel(entry: FallbackModel, signal?: AbortSignal): Promise<void> {
+  const operation = modelSwitchQueue.then(async () => {
+    if (signal?.aborted) return;
+    const pi = state.extensionApi;
+    if (!pi) return;
+    const current = state.sharedCtx?.model;
+    if (current && modelKey(current) === modelKey(entry.model)) return;
+    if (signal?.aborted) return;
+
+    const cancelExpectedSelection = expectModelSelection(entry.model);
+    try {
+      const ok = await pi.setModel(entry.model);
+      if (!ok) {
+        cancelExpectedSelection();
+        return;
+      }
+      if (signal?.aborted) return;
+      const level = entry.reasoningEffort ?? state.primaryThinkingLevel;
+      if (level) pi.setThinkingLevel(level);
+      if (!signal?.aborted) {
+        state.sharedCtx?.ui.notify(`Switched to ${formatModel(entry.model)}${level ? ` (${level})` : ""}.`, "info");
+      }
+    } catch {
+      // The request can outlive its session during /reload or replacement. The
+      // interception owner aborts it; never let a stale UI/model switch strand
+      // the output stream.
+      cancelExpectedSelection();
+    }
+  });
+  modelSwitchQueue = operation.catch(() => undefined);
+  await operation;
 }

package/src/prompt.ts

@@ -1,89 +1,64 @@
-import type { ExtensionContext } from "@mariozechner/pi-coding-agent";
-import type { Api, Context, Model, SimpleStreamOptions } from "@mariozechner/pi-ai";
-import { CLAUDE_CODE_IDENTITY, CLAUDE_CODE_IDENTITY_PATTERN, PI_IDENTITY_SENTENCE_PATTERN, PI_REMOVAL_ANCHORS } from "./constants.js";
-import { state } from "./state.js";
-
-export function sanitiseSystemPrompt(raw: string): string {
-  const paragraphs = raw.split(/\n\n+/);
-  const filtered = paragraphs.filter((p) =>
-    !PI_REMOVAL_ANCHORS.some((anchor) => p.includes(anchor)),
-  );
-
-  return filtered
-    .join("\n\n")
-    .replace(CLAUDE_CODE_IDENTITY_PATTERN, "")
-    .replace(PI_IDENTITY_SENTENCE_PATTERN, "")
-    .replace(/\n{3,}/g, "\n\n")
-    .trim();
-}
-
-/**
- * Returns true if Anthropic OAuth is configured for this session, regardless
- * of which model is currently active. This handles cases where a synthetic or
- * temporary model is active at before_agent_start time.
- */
-export function isAnthropicOAuthSession(ctx: ExtensionContext): boolean {
-  return ctx.modelRegistry.isUsingOAuth(
-    { provider: "anthropic" } as Parameters<typeof ctx.modelRegistry.isUsingOAuth>[0],
-  );
-}
-
-export function isAnthropicOAuthToken(value: string | undefined): boolean {
-  return Boolean(value?.includes("sk-ant-oat"));
-}
-
-function headerValue(headers: Record<string, string> | undefined, name: string): string | undefined {
-  if (!headers) return undefined;
-  const direct = headers[name];
-  if (direct !== undefined) return direct;
-  const lower = name.toLowerCase();
-  return Object.entries(headers).find(([key]) => key.toLowerCase() === lower)?.[1];
-}
-
-function requestAuthIsAnthropicOAuth(options?: SimpleStreamOptions): boolean | undefined {
-  if (typeof options?.apiKey === "string" && options.apiKey.length > 0) {
-    return isAnthropicOAuthToken(options.apiKey);
-  }
-
-  const authorization = headerValue(options?.headers, "authorization");
-  if (authorization) {
-    const bearer = authorization.match(/^\s*Bearer\s+(.+?)\s*$/i)?.[1] ?? authorization;
-    return isAnthropicOAuthToken(bearer);
-  }
-
-  return undefined;
-}
-
-export function isAnthropicSubscriptionRequest(
-  model: Model<Api>,
-  options?: SimpleStreamOptions,
-  ctx: ExtensionContext | undefined = state.sharedCtx,
-): boolean {
-  if (model.provider !== "anthropic") return false;
-
-  // Prefer the actual per-request auth. This avoids both false negatives
-  // (OAuth token supplied via options/fallback auth while modelRegistry does not
-  // report OAuth) and false positives (registry has OAuth, but this request was
-  // explicitly made with a normal API key).
-  const requestAuth = requestAuthIsAnthropicOAuth(options);
-  if (requestAuth !== undefined) return requestAuth;
-
-  return Boolean(ctx?.modelRegistry.isUsingOAuth(model));
-}
-
-export function anthropicSubscriptionContext(
-  model: Model<Api>,
-  context: Context,
-  options?: SimpleStreamOptions,
-  ctx: ExtensionContext | undefined = state.sharedCtx,
-): Context {
-  if (!isAnthropicSubscriptionRequest(model, options, ctx)) return context;
-
-  const sanitised = sanitiseSystemPrompt(context.systemPrompt ?? "");
-  return {
-    ...context,
-    systemPrompt: sanitised
-      ? `${CLAUDE_CODE_IDENTITY}\n\n${sanitised}`
-      : CLAUDE_CODE_IDENTITY,
-  };
-}
+import { CLAUDE_CODE_IDENTITY, CLAUDE_CODE_IDENTITY_PATTERN, PI_HARNESS_IDENTITY_PATTERN, PI_IDENTITY_SENTENCE_PATTERN, PI_REMOVAL_ANCHORS } from "./constants.js";
+
+export function sanitiseSystemPrompt(raw: string): string {
+  const paragraphs = raw.split(/\n\n+/);
+  const filtered = paragraphs.filter((p) =>
+    !PI_REMOVAL_ANCHORS.some((anchor) => p.includes(anchor)),
+  );
+
+  return filtered
+    .join("\n\n")
+    .replace(CLAUDE_CODE_IDENTITY_PATTERN, "")
+    .replace(PI_IDENTITY_SENTENCE_PATTERN, "")
+    .replace(PI_HARNESS_IDENTITY_PATTERN, "")
+    .replace(/\n{3,}/g, "\n\n")
+    .trim();
+}
+
+interface SystemTextBlock {
+  type: string;
+  text?: unknown;
+  [key: string]: unknown;
+}
+
+function isPiClaudeCodeIdentityBlock(block: unknown): block is SystemTextBlock {
+  if (!block || typeof block !== "object") return false;
+  const candidate = block as SystemTextBlock;
+  return candidate.type === "text"
+    && typeof candidate.text === "string"
+    && candidate.text.trim() === CLAUDE_CODE_IDENTITY;
+}
+
+/**
+ * Sanitise the host prompt in the exact Anthropic OAuth shape generated by the
+ * current pi-ai runtime: the Claude Code identity is the first system block.
+ * Looking only at that exact first block avoids treating a later user-authored
+ * identity mention as proof of OAuth. The runtime remains solely responsible
+ * for inserting the identity and selecting OAuth headers.
+ */
+export function sanitiseAnthropicPayloadSystem(payload: unknown): unknown {
+  if (!payload || typeof payload !== "object") return payload;
+  const system = (payload as { system?: unknown }).system;
+  if (!Array.isArray(system) || !isPiClaudeCodeIdentityBlock(system[0])) return payload;
+
+  let changed = false;
+  const newSystem: unknown[] = [system[0]];
+  for (let i = 1; i < system.length; i++) {
+    const block = system[i];
+    if (
+      block && typeof block === "object"
+      && (block as SystemTextBlock).type === "text"
+      && typeof (block as SystemTextBlock).text === "string"
+    ) {
+      const original = (block as SystemTextBlock).text as string;
+      const sanitised = sanitiseSystemPrompt(original);
+      if (sanitised !== original) changed = true;
+      if (sanitised) newSystem.push({ ...block, text: sanitised });
+      else changed = true;
+    } else {
+      newSystem.push(block);
+    }
+  }
+
+  return changed ? { ...payload, system: newSystem } : payload;
+}

package/src/response-observer.ts

@@ -0,0 +1,52 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+
+type ResponseObserver = (response: Response, requestUrl: string | undefined) => void;
+interface FetchObserverSlot {
+  storage: AsyncLocalStorage<ResponseObserver>;
+  previous: typeof fetch;
+  wrapper: typeof fetch;
+}
+
+const FETCH_OBSERVER_SYMBOL = Symbol.for("oira666.pi-limits-wait.attempt-fetch-observer.v1");
+type InterceptableGlobal = typeof globalThis & { [FETCH_OBSERVER_SYMBOL]?: FetchObserverSlot };
+
+function requestUrl(input: Parameters<typeof fetch>[0]): string | undefined {
+  if (typeof input === "string") return input;
+  if (input instanceof URL) return input.href;
+  return input.url;
+}
+
+function observerSlot(): FetchObserverSlot | undefined {
+  if (typeof globalThis.fetch !== "function") return undefined;
+  const target = globalThis as InterceptableGlobal;
+  const existing = target[FETCH_OBSERVER_SYMBOL];
+  if (existing) {
+    // Never stack another limits-wait wrapper if another owner replaced fetch
+    // after us. In that case onResponse/provider errors remain the fallback.
+    return globalThis.fetch === existing.wrapper ? existing : undefined;
+  }
+
+  const slot = {} as FetchObserverSlot;
+  slot.storage = new AsyncLocalStorage<ResponseObserver>();
+  slot.previous = globalThis.fetch.bind(globalThis);
+  slot.wrapper = (async (...args: Parameters<typeof fetch>) => {
+    const observer = slot.storage.getStore();
+    const url = requestUrl(args[0]);
+    const response = await slot.previous(...args);
+    observer?.(response, response.url || url);
+    return response;
+  }) as typeof fetch;
+  Object.defineProperty(target, FETCH_OBSERVER_SYMBOL, { configurable: true, value: slot });
+  globalThis.fetch = slot.wrapper;
+  return slot;
+}
+
+/**
+ * Observe fetch responses only in the async execution chain of one provider
+ * attempt. This is observational only: it never throws or consumes a body.
+ * Outside that chain the stable process trampoline is transparent.
+ */
+export function withAttemptResponseObserver<T>(observer: ResponseObserver, callback: () => T): T {
+  const slot = observerSlot();
+  return slot ? slot.storage.run(observer, callback) : callback();
+}

package/src/settings.ts

@@ -1,15 +1,15 @@
 import { existsSync, readFileSync } from "fs";
 import { homedir } from "os";
 import { join, resolve } from "path";
-import { getAgentDir, type ExtensionContext } from "@mariozechner/pi-coding-agent";
-import type { ThinkingLevel } from "@mariozechner/pi-agent-core";
+import { getAgentDir, type ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { ModelThinkingLevel } from "@earendil-works/pi-ai";
 import { FALLBACK_MODELS_KEY, SETTINGS_FILE_NAME } from "./constants.js";
 import { formatModel, modelKey } from "./models.js";
 import { state } from "./state.js";
 import type { ConfiguredModel } from "./types.js";
 
-function isThinkingLevel(value: unknown): value is ThinkingLevel {
-  return ["off", "minimal", "low", "medium", "high", "xhigh"].includes(String(value));
+function isThinkingLevel(value: unknown): value is ModelThinkingLevel {
+  return ["off", "minimal", "low", "medium", "high", "xhigh", "max"].includes(String(value));
 }
 
 export function parseConfiguredModels(raw: unknown): ConfiguredModel[] {