pi-bob 0.2.0 → 0.2.2

package/README.md

@@ -4,12 +4,24 @@ Pi provider package for IBM Bob / IBM-approved enterprise model endpoints.
 
 The package registers Bob through Pi's built-in compatible provider APIs and discovers the currently exposed model catalog from Bob's authenticated `/inference/v1/model/info` endpoint. It does not scrape Bob, extract browser/session credentials, or bypass IBM-approved access paths.
 
+> **✅ Works with IBM Bob Shell / Bob CLI 2.x (verified against `bobshell@2.0.1`, 2026-08-31).**
+> SSO login, token refresh, and live model discovery all work against Bob 2.0 — 13 models discovered, including `premium`, `premium-ide`, `ultra`, `fast`, and `wxO-model` (1M ctx). One caveat: under 2.x, Bob only accepts the default **`openai-completions`** adapter; `anthropic-messages` and `openai-responses` are rejected with 403 by Bob-side entitlement. 1.x Bob Shell installations keep working — the parser accepts both payload shapes. See [Discovered local Bob Shell settings](#discovered-local-bob-shell-settings) for the full 2.x change list.
+
 ## Discovered local Bob Shell settings
 
-From the installed `bobshell@1.0.6` package and the local redacted Bob configuration:
+Updated for the installed `bobshell@2.0.1` package (upgraded from 1.0.6; findings verified against the live endpoint on 2026-08-31):
+
+- Bob Shell 2.x moved stored SSO tokens to `~/.bob/settings/auth-secrets.json` (key `bob.auth.tokens-<gateway>`); `~/.bob/settings.json` keeps only non-secret settings. This extension still reads only `ibm.instanceId`/`ibm.teamId` from there and still ignores Bob's secrets.
+- Token endpoints are unchanged in practice: 2.x builds `${gateway}/authn` + `v1/auth/token|refresh`, which resolves to the same `/authn/v1/auth/token` and `/authn/v1/auth/refresh` routes used here. The web login URL is now assembled as `https://bob.ibm.com` + `/login`; the final URL is the same as the 1.x constant.
+- **Breaking:** 2.x `model/info` entries dropped `litellm_params` (the backend identifier) and now carry `max_output_tokens` and `supports_prompt_caching` alongside `max_tokens`. The parser accepts both shapes and falls back to the route name when the backend is missing.
+- **Breaking:** 2.x `model/info` requires `x-instance-id` (HTTP 400 without it); `x-team-id` stays optional. The extension already sends both from Bob settings or the JWT `instances` claim.
+- Model tiers were renamed: 1.x `premium`/`pro`/`flash`/`flash-lite` became 2.x tiers `fast`/`premium`/`ultra` (`explorer` exists but is hidden). Live catalog also exposes `premium-ide`, `premium-shell`, `sonnet-4.5`, `wxO-model` (1M ctx / 64k out), `gpt-oss-20b`, and granite/rnj code models. The `premium` alias still exists, so the fallback catalog stays valid.
+- **Breaking (entitlement):** under 2.0, the `anthropic-messages` and `openai-responses` routes return `403 Access denied` with a valid token (routes exist; access is denied for this instance). Only the default `openai-completions` adapter works; treat the alternates as unavailable until IBM grants access.
 
-- Bob Shell CLI: `/opt/homebrew/bin/bob`
-- Bob Shell package: `/opt/homebrew/lib/node_modules/bobshell`
+From the installed `bobshell@1.0.6` package and the local redacted Bob configuration (historical):
+
+- Bob Shell CLI: `bob`
+- Bob Shell package: `bobshell`
 - Installed auth method: `sso`
 - Default Bob API host: `https://api.us-east.bob.ibm.com`
 - OpenAI-compatible chat base URL: `https://api.us-east.bob.ibm.com/inference/v1`
@@ -36,6 +48,8 @@ Set `IBM_BOB_API` to one of Pi's compatible API adapters:
 - `openai-responses` — OpenAI Responses-compatible routes.
 - `anthropic-messages` — Anthropic Messages-compatible routes.
 
+Under Bob Shell 2.x, Bob currently accepts only the default `openai-completions` adapter; the other two return `403 Access denied` regardless of extension settings (verified 2026-08-31).
+
 The extension registers provider id `ibm-bob`. It uses an isolated `ibm-bob-compatible` Pi API adapter internally, then delegates serialization and streaming to the selected built-in adapter. This prevents Bob-specific authentication rules from affecting other providers.
 
 ## Dynamic model discovery
@@ -43,7 +57,7 @@ The extension registers provider id `ibm-bob`. It uses an isolated `ibm-bob-comp
 Model discovery is enabled by default:
 
 - With `IBM_BOB_API_KEY` or `IBM_BOB_KEY`, the extension fetches `/inference/v1/model/info` during Pi's async extension startup. This makes current models available to `--list-models` and `/model` immediately.
-- With `/login ibm-bob`, the extension fetches the catalog after login and on each token refresh. A sanitized, non-secret copy is cached with Pi's OAuth credentials so the models can be restored on later startups.
+- With `/login ibm-bob`, the extension fetches the catalog after login, and on token refresh only when no catalog is already cached (reusing a cached catalog avoids holding Pi's global auth-store lock across a network call). A sanitized, non-secret copy is cached with Pi's OAuth credentials so the models can be restored on later startups.
 - Entries returned by the authenticated catalog are registered when `model_info.exposed` is omitted or `true`. Routes explicitly marked `exposed: false` are ignored.
 - HTTP failures, timeouts, malformed responses, empty catalogs, and catalogs with no visible models retain the previous SSO catalog or fall back to `IBM_BOB_MODELS`. Bob still enforces route access during inference.
 
@@ -54,7 +68,7 @@ Discovered context limits, output limits, vision support, reasoning support, bac
 Use Bob SSO through Pi:
 
 ```bash
-pi -e /Users/larry.song/work/hashicorp/pi-bob
+pi -e .
 # inside Pi:
 #   /login ibm-bob
 #   /model ibm-bob/premium
@@ -67,8 +81,8 @@ For non-interactive use with an approved Bob API key, run:
 ```bash
 export IBM_BOB_API_KEY="..." # IBM_BOB_KEY is also accepted; do not commit either
 
-pi -e /Users/larry.song/work/hashicorp/pi-bob --list-models
-pi -e /Users/larry.song/work/hashicorp/pi-bob --model ibm-bob/premium
+pi -e . --list-models
+pi -e . --model ibm-bob/premium
 ```
 
 API keys use Bob's `Authorization: Apikey ...` scheme by default. If your approved credential is instead a bearer token, set `IBM_BOB_AUTH_SCHEME=Bearer`. Pi resolves credentials in this order: runtime `--api-key`, a stored credential (including SSO), then the provider's environment-key fallback. The model catalog follows stored SSO metadata when SSO remains configured. Run `/logout ibm-bob` before switching from SSO to either `IBM_BOB_API_KEY` or runtime `--api-key`; runtime-only keys cannot drive startup discovery.
@@ -109,7 +123,7 @@ For SSO, do **not** copy a token out of Bob's local credential store unless IBM
 | `IBM_BOB_READ_BOBSHELL_SETTINGS` | `true` | Read non-secret `instanceId`/`teamId` from `~/.bob/settings.json`. |
 | `IBM_BOB_INSTANCE_ID` | Bob setting | Override `x-instance-id`. |
 | `IBM_BOB_TEAM_ID` | Bob setting | Override `x-team-id`. |
-| `IBM_BOB_USER_AGENT` | `pi-bob/0.1.0` | User-Agent header sent to Bob endpoint. |
+| `IBM_BOB_USER_AGENT` | `pi-bob/0.2.2` | User-Agent header sent to Bob endpoint. |
 
 ### Auth headers
 
@@ -141,21 +155,24 @@ export IBM_BOB_MAX_TOKENS_FIELD=max_tokens
 ```
 
 Bob's OpenAI-compatible route currently rejects `tools[].function.strict`, so `IBM_BOB_SUPPORTS_STRICT_MODE=false` is the default.
+It also rejects OpenAI-specific `store` and `prompt_cache_key` request properties with a bare `422`, so both are always disabled for the OpenAI adapters.
 
 ## Validation performed
 
-Bob Shell SSO itself works locally:
+### Verified against Bob Shell 2.0.1 (2026-08-31)
 
-```bash
-bob --auth-method sso -m premium -p 'Reply with exactly: bob-ok' --hide-intermediary-output --output-format json
-```
+- Live discovery through Pi: `pi --list-models` shows all 13 catalog models (`premium`, `premium-ide`, `premium-shell`, `ultra`, `fast`, `explorer`, `sonnet-4.5`, `wxO-model`, `gpt-oss-20b`, granite/rnj) from any directory, using stored SSO credentials.
+- End-to-end inference through `openai-completions`: `premium`, `ultra`, and `premium-shell` all responded correctly to exact-reply smokes.
+- SSO refresh on `/authn/v1/auth/refresh` returned `200` with a rotated refresh token; the refreshed token immediately passed `model/info`.
+- `anthropic-messages` and `openai-responses` routes: `403 Access denied` with a valid token — Bob-side entitlement change, not an extension defect.
+- `bun test`: 33 tests pass, including a fixture built from an observed 2.x `model/info` payload (no `litellm_params`, `max_output_tokens`, `supports_prompt_caching`).
 
-The response included `bob-ok` and successful usage stats for model `premium`.
+### Earlier validation (Bob Shell 1.x era)
 
 The unauthenticated Bob model-info endpoint responds as expected when called with a normal User-Agent:
 
 ```bash
-curl -H 'User-Agent: pi-bob/0.1.0' \
+curl -H 'User-Agent: pi-bob/0.2.2' \
   https://api.us-east.bob.ibm.com/inference/v1/model/info
 ```
 
@@ -197,24 +214,45 @@ Result:
 pi-bob-ok
 ```
 
+## Troubleshooting
+
+**`/login ibm-bob` freezes after the browser returns to Pi.** Pi refreshes
+model catalogs for built-in providers after every login by fetching
+`https://pi.dev/api/models/providers/<id>` (the remote-catalog provider). If
+pi.dev's API is unreachable or hangs from your network, that post-login fetch
+blocks with no timeout for roughly 5 minutes, and Ctrl-C cannot cancel it.
+Run Pi with `PI_OFFLINE=1` to skip Pi's network catalog refresh entirely; the
+login then returns to the prompt immediately after SSO, and ibm-bob's own
+model discovery still runs.
+
+**`/model` shows only `premium` under `ibm-bob`.** The stored credentials carry no cached model catalog — typical for credentials created before this version, or after Bob changes its catalog shape. Run `/login ibm-bob` once: login always rediscovers the catalog and re-attaches it to the stored credentials, and every later startup reuses it. Do **not** hand-edit `~/.pi/agent/auth.json` to add the catalog; Pi's auth store manages that file and may silently drop hand-written fields.
+
+**Debugging the login flow.** Run with `IBM_BOB_DEBUG=1` and stderr
+redirected to a file to see per-step timing for the SSO callback, token
+exchange, and model discovery:
+
+```bash
+IBM_BOB_DEBUG=1 pi 2>/tmp/pi-bob-debug.log
+```
+
 ## Install options
 
 Temporary test load:
 
 ```bash
-pi -e /Users/larry.song/work/hashicorp/pi-bob
+pi -e .
 ```
 
 Install as a local Pi package:
 
 ```bash
-pi install /Users/larry.song/work/hashicorp/pi-bob
+pi install npm:pi-bob
 ```
 
 Remove later:
 
 ```bash
-pi remove /Users/larry.song/work/hashicorp/pi-bob
+pi remove npm:pi-bob
 ```
 
 ## Next steps

package/extensions/bob.ts

@@ -239,7 +239,7 @@ function parseJsonHeaders(): Record<string, string> | undefined {
 
 function buildHeaders(settings?: BobShellSettings): Record<string, string> | undefined {
 	const headers: Record<string, string> = {
-		"User-Agent": env("IBM_BOB_USER_AGENT") ?? "pi-bob/0.1.0",
+		"User-Agent": env("IBM_BOB_USER_AGENT") ?? "pi-bob/0.2.2",
 	};
 
 	const instanceId = env("IBM_BOB_INSTANCE_ID") ?? settings?.ibm?.instanceId;
@@ -282,6 +282,10 @@ function buildOpenAiCompat(api: CompatibleApi): Record<string, unknown> | undefi
 		supportsReasoningEffort: envBool("IBM_BOB_SUPPORTS_REASONING_EFFORT", false),
 		supportsUsageInStreaming: envBool("IBM_BOB_SUPPORTS_USAGE_IN_STREAMING", true),
 		supportsStrictMode: envBool("IBM_BOB_SUPPORTS_STRICT_MODE", false),
+		// pi-ai auto-detect defaults these to true for unknown endpoints; Bob's
+		// strict validator rejects `store` and `prompt_cache_key` with a bare 422.
+		supportsStore: false,
+		supportsLongCacheRetention: false,
 	};
 
 	const maxTokensField = env("IBM_BOB_MAX_TOKENS_FIELD") as MaxTokensField | undefined;
@@ -338,10 +342,12 @@ export function parseBobModelCatalog(payload: unknown): BobDiscoveredModel[] {
 	const seen = new Set<string>();
 	let structurallyValidEntries = 0;
 	for (const entry of payload.data) {
-		if (!isRecord(entry) || !isRecord(entry.model_info) || !isRecord(entry.litellm_params)) continue;
+		if (!isRecord(entry) || !isRecord(entry.model_info)) continue;
 		const id = safeCatalogLabel(entry.model_name);
-		const backend = safeCatalogLabel(entry.litellm_params.model);
-		if (!id || !backend) continue;
+		if (!id) continue;
+		// bobshell 2.x model/info entries dropped litellm_params; fall back to the
+		// route name itself so discovery still works against 2.x payloads.
+		const backend = safeCatalogLabel((entry.litellm_params as Record<string, unknown> | undefined)?.model) || id;
 		const exposed = entry.model_info.exposed;
 		if (exposed !== undefined && typeof exposed !== "boolean") continue;
 		structurallyValidEntries++;
@@ -359,7 +365,10 @@ export function parseBobModelCatalog(payload: unknown): BobDiscoveredModel[] {
 				entry.model_info.supports_thinking === true,
 			supportsVision: entry.model_info.supports_vision === true,
 			contextWindow: positiveNumber(entry.model_info.max_input_tokens),
-			maxTokens: positiveNumber(entry.model_info.max_tokens),
+			// bobshell 2.x adds max_output_tokens; keep the conservative 1.x
+			// max_tokens precedence and only use it as a fallback.
+			maxTokens:
+				positiveNumber(entry.model_info.max_tokens) ?? positiveNumber(entry.model_info.max_output_tokens),
 			cost: {
 				input: perMillionCost(entry.model_info.input_cost_per_token),
 				output: perMillionCost(entry.model_info.output_cost_per_token),
@@ -497,18 +506,23 @@ async function fetchBobModelCatalog(
 	authScheme: string,
 	settings?: BobShellSettings,
 ): Promise<BobDiscoveredModel[]> {
+	const startedAt = Date.now();
 	const controller = new AbortController();
 	const timeoutMs = envInt("IBM_BOB_MODEL_DISCOVERY_TIMEOUT_MS", DEFAULT_MODEL_DISCOVERY_TIMEOUT_MS);
 	const timeout = setTimeout(() => controller.abort(), timeoutMs);
 	const headers: Record<string, string> = {
 		Accept: "application/json",
 		Authorization: `${authScheme} ${accessToken}`,
-		"User-Agent": env("IBM_BOB_USER_AGENT") ?? "pi-bob/0.1.0",
+		"User-Agent": env("IBM_BOB_USER_AGENT") ?? "pi-bob/0.2.2",
 	};
-	const instanceId = env("IBM_BOB_INSTANCE_ID") ?? settings?.ibm?.instanceId;
+	const instanceId =
+		env("IBM_BOB_INSTANCE_ID") ?? settings?.ibm?.instanceId ?? readInstanceFromJwt(accessToken);
 	const teamId = env("IBM_BOB_TEAM_ID") ?? settings?.ibm?.teamId;
 	if (instanceId) headers["x-instance-id"] = instanceId;
 	if (teamId) headers["x-team-id"] = teamId;
+	bobLog(
+		`model discovery → ${providerBaseUrl().replace(/\/+$/, "")}/model/info (instance=${instanceId ?? "none"}, timeout=${timeoutMs}ms)`,
+	);
 
 	try {
 		const response = await fetch(`${providerBaseUrl().replace(/\/+$/, "")}/model/info`, {
@@ -521,11 +535,16 @@ async function fetchBobModelCatalog(
 				`IBM Bob model discovery failed: ${response.status} ${truncateHttpBody(await readBoundedResponseBody(response))}`.trim(),
 			);
 		}
-		return parseBobModelCatalog(await readJsonResponse(response));
+		const catalog = parseBobModelCatalog(await readJsonResponse(response));
+		bobLog(`model discovery ok: ${catalog.length} models in ${Date.now() - startedAt}ms`);
+		return catalog;
 	} catch (error) {
 		if (controller.signal.aborted) {
 			throw new Error(`IBM Bob model discovery timed out after ${timeoutMs}ms.`);
 		}
+		bobLog(
+			`model discovery failed in ${Date.now() - startedAt}ms: ${error instanceof Error ? error.message : String(error)}`,
+		);
 		throw error;
 	} finally {
 		clearTimeout(timeout);
@@ -572,6 +591,21 @@ function jwtExpiry(accessToken: string): number | undefined {
 	return typeof exp === "number" ? exp * 1000 - 5 * 60 * 1000 : undefined;
 }
 
+function readInstanceFromJwt(accessToken: string | undefined): string | undefined {
+	if (!accessToken) return undefined;
+	const instances = jwtPayload(accessToken)?.instances;
+	if (!Array.isArray(instances) || instances.length === 0) return undefined;
+	for (const entry of instances) {
+		if (isRecord(entry) && typeof entry.id === "string" && entry.id) return entry.id;
+	}
+	return undefined;
+}
+
+function bobLog(message: string): void {
+	if (!envBool("IBM_BOB_DEBUG", false)) return;
+	console.warn(`[pi-bob] ${new Date().toISOString()} ${message}`);
+}
+
 export function applyBobAuthHeaders(
 	headers: Record<string, string | null | undefined>,
 	resolvedCredential?: string,
@@ -666,6 +700,7 @@ async function startCallbackServer(state: string): Promise<CallbackServer> {
 
 	const code = new Promise<string>((resolve, reject) => {
 		server.on("request", (req, res) => {
+			bobLog(`login: callback request received: ${(req.url ?? "").split("?")[0] || "(no path)"}`);
 			if (!req.url?.startsWith("/bob-callback")) {
 				res.writeHead(404, { "Content-Type": "text/plain" });
 				res.end("Not Found");
@@ -679,6 +714,7 @@ async function startCallbackServer(state: string): Promise<CallbackServer> {
 				const error = url.searchParams.get("error");
 
 				if (returnedState !== state) {
+					bobLog(`login: callback state mismatch (expected ${state}, got ${returnedState})`);
 					res.writeHead(400, { "Content-Type": "text/plain" });
 					res.end("Invalid state parameter");
 					reject(new Error("Invalid state parameter from IBM Bob SSO callback."));
@@ -686,6 +722,7 @@ async function startCallbackServer(state: string): Promise<CallbackServer> {
 				}
 
 				if (error) {
+					bobLog(`login: callback auth error: ${error}`);
 					res.writeHead(400, { "Content-Type": "text/plain" });
 					res.end("Authentication failed");
 					reject(new Error(`IBM Bob SSO failed: ${error}`));
@@ -693,6 +730,7 @@ async function startCallbackServer(state: string): Promise<CallbackServer> {
 				}
 
 				if (!authCode) {
+					bobLog("login: callback missing authorization code");
 					res.writeHead(400, { "Content-Type": "text/plain" });
 					res.end("Missing authorization code");
 					reject(new Error("IBM Bob SSO callback did not include an authorization code."));
@@ -712,7 +750,10 @@ async function startCallbackServer(state: string): Promise<CallbackServer> {
 				reject(error);
 			}
 		});
-		server.on("error", reject);
+		server.on("error", (error) => {
+			bobLog(`login: callback server error: ${error instanceof Error ? error.message : String(error)}`);
+			reject(error);
+		});
 	});
 
 	await new Promise<void>((resolve, reject) => {
@@ -733,13 +774,15 @@ async function startCallbackServer(state: string): Promise<CallbackServer> {
 }
 
 async function postToken(path: "/authn/v1/auth/token" | "/authn/v1/auth/refresh", body: unknown): Promise<BobTokenResponse> {
+	const startedAt = Date.now();
 	const controller = new AbortController();
 	const timeoutMs = envInt("IBM_BOB_TOKEN_REQUEST_TIMEOUT_MS", DEFAULT_TOKEN_REQUEST_TIMEOUT_MS);
 	const timeout = setTimeout(() => controller.abort(), timeoutMs);
+	bobLog(`token request → ${bobOrigin()}${path} (timeout=${timeoutMs}ms)`);
 	try {
 		const response = await fetch(`${bobOrigin()}${path}`, {
 			method: "POST",
-			headers: { "Content-Type": "application/json", "User-Agent": env("IBM_BOB_USER_AGENT") ?? "pi-bob/0.1.0" },
+			headers: { "Content-Type": "application/json", "User-Agent": env("IBM_BOB_USER_AGENT") ?? "pi-bob/0.2.2" },
 			body: JSON.stringify(body),
 			signal: controller.signal,
 		});
@@ -750,6 +793,7 @@ async function postToken(path: "/authn/v1/auth/token" | "/authn/v1/auth/refresh"
 			);
 		}
 
+		bobLog(`token request ok in ${Date.now() - startedAt}ms`);
 		return (await readJsonResponse(response)) as BobTokenResponse;
 	} catch (error) {
 		if (controller.signal.aborted) throw new Error(`IBM Bob SSO token request timed out after ${timeoutMs}ms.`);
@@ -760,26 +804,73 @@ async function postToken(path: "/authn/v1/auth/token" | "/authn/v1/auth/refresh"
 }
 
 async function loginBob(callbacks: OAuthLoginCallbacks): Promise<OAuthCredentials> {
+	const startedAt = Date.now();
+	const elapsed = () => `${((Date.now() - startedAt) / 1000).toFixed(1)}s`;
+	bobLog("login: starting IBM Bob SSO");
+
 	const state = randomBytes(16).toString("hex");
 	const callbackServer = await startCallbackServer(state);
+	bobLog(`login: callback server listening at ${callbackServer.callbackUri} (+${elapsed()})`);
+
 	const loginUrl = new URL(bobWebLoginUrl());
 	loginUrl.searchParams.set("callback_uri", callbackServer.callbackUri);
 	loginUrl.searchParams.set("state", state);
 
+	const signal = callbacks.signal;
 	let loginTimeout: ReturnType<typeof setTimeout> | undefined;
+	let progressInterval: ReturnType<typeof setInterval> | undefined;
+	let onAbort: (() => void) | undefined;
 	try {
 		callbacks.onAuth({ url: loginUrl.toString() });
+		bobLog(`login: browser opened for SSO (+${elapsed()})`);
 
 		const timeoutMs = envInt("IBM_BOB_LOGIN_TIMEOUT_MS", 180_000);
 		const timeout = new Promise<never>((_resolve, reject) => {
-			loginTimeout = setTimeout(() => reject(new Error("IBM Bob SSO timed out.")), timeoutMs);
+			loginTimeout = setTimeout(() => {
+				bobLog(`login: SSO timed out after ${timeoutMs}ms (+${elapsed()})`);
+				reject(new Error("IBM Bob SSO timed out."));
+			}, timeoutMs);
 		});
 
-		const code = await Promise.race([callbackServer.code, timeout]);
+		const abort =
+			signal === undefined
+				? undefined
+				: new Promise<never>((_resolve, reject) => {
+						if (signal.aborted) {
+							bobLog("login: cancelled (abort signal already fired)");
+							reject(new Error("Login cancelled"));
+							return;
+						}
+						onAbort = () => {
+							bobLog(`login: cancelled via abort signal (+${elapsed()})`);
+							reject(new Error("Login cancelled"));
+						};
+						signal.addEventListener("abort", onAbort, { once: true });
+					});
+
+		progressInterval = setInterval(() => {
+			bobLog(`login: still waiting for SSO browser callback (+${elapsed()})`);
+		}, Math.min(15_000, Math.max(5_000, Math.floor(timeoutMs / 12))));
+
+		const races: Array<Promise<string | never>> = [callbackServer.code, timeout];
+		if (abort) races.push(abort);
+		const code = await Promise.race(races);
+		bobLog(`login: SSO callback received (+${elapsed()})`);
+
 		const credentials = credentialsFromTokenResponse(await postToken("/authn/v1/auth/token", { code }));
-		return attachBobModelCatalog(credentials);
+		bobLog(`login: access token exchanged (+${elapsed()})`);
+
+		const withCatalog = await attachBobModelCatalog(credentials);
+		bobLog(`login: model catalog attached (+${elapsed()})`);
+
+		return withCatalog;
+	} catch (error) {
+		bobLog(`login: failed (+${elapsed()}): ${error instanceof Error ? error.message : String(error)}`);
+		throw error;
 	} finally {
 		if (loginTimeout) clearTimeout(loginTimeout);
+		if (progressInterval) clearInterval(progressInterval);
+		if (onAbort && signal) signal.removeEventListener("abort", onAbort);
 		callbackServer.close();
 	}
 }
@@ -790,6 +881,15 @@ async function refreshBobToken(credentials: OAuthCredentials): Promise<OAuthCred
 		await postToken("/authn/v1/auth/refresh", { refresh_token: credentials.refresh }),
 		credentials.refresh,
 	);
+	// Token refresh runs inside pi-ai's locked credentials.modify (auth.json lock).
+	// Avoid holding that global lock across a model-discovery network call when a
+	// catalog is already cached; rediscovery still happens on login and whenever
+	// no cached catalog exists.
+	const existingCatalog = cachedCatalog(credentials);
+	if (existingCatalog) {
+		bobLog(`refresh: reusing cached catalog (${existingCatalog.length} models); skipping rediscovery`);
+		return { ...refreshed, bobModelCatalog: existingCatalog };
+	}
 	return attachBobModelCatalog(refreshed, credentials);
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-bob",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "type": "module",
   "description": "Pi provider extension for IBM Bob / IBM-approved compatible model endpoints.",
   "keywords": [
@@ -24,7 +24,7 @@
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/songlining/pi-bob.git"
+    "url": "git+https://github.com/songlining/pi-bob.git"
   },
   "bugs": {
     "url": "https://github.com/songlining/pi-bob/issues"