@oh-my-pi/pi-ai 16.1.21 → 16.1.23

package/CHANGELOG.md

@@ -2,6 +2,29 @@
 
 ## [Unreleased]
 
+## [16.1.23] - 2026-06-26
+
+### Added
+
+- Added a third streaming thinking-loop detection heuristic to catch "progress-lexicon stalls" where models endlessly reshuffle motivational filler without introducing new vocabulary or concrete technical references
+- Added branded wordmark and logo animation to authentication flow
+- Added a third streaming thinking-loop detection shape — a *progress-lexicon stall* — alongside verbatim tail repetition and near-duplicate (trigram) segments. It catches reasoning-summarizer loops that reshuffle the same motivational filler ("just doing it, pushing ahead, maintaining momentum") into fresh word order every paragraph: word-trigrams never cluster, but a run of substantial segments that recycle the recent vocabulary and introduce no *new* concrete reference (path / identifier / code-span) trips the guard. Summarizer title/heading lines (`**Bold Title**`, `## Heading`) are stripped before analysis so their ever-changing wording cannot mask the stall by inflating novelty. Calibrated against 537k real non-Gemini reasoning blocks (zero false positives at novelty floor 0.2 / run length 8; the real loop sustains runs of 10+).
+- Added CoreWeave Serverless Inference provider login support via `COREWEAVE_API_KEY` and `WANDB_API_KEY` fallback.
+
+### Changed
+
+- Redesigned the OAuth callback page (`oauth.html`) to match the oh-my-pi web brand language: OKLCH purple-tinted dark neutrals, magenta→iris→cyan brand gradient on the wordmark, frosted-glass card over an ascii grid backdrop, and a colored status halo around the success/error icon. All assets are inlined; the `__OAUTH_STATE__` injection contract and success/error JS logic are unchanged.
+
+### Fixed
+
+- Fixed local llama.cpp (and any local OpenAI-compatible server rendering the Qwen3.6+ chat template) re-processing the full prompt every new user message even with `replayReasoningContent` enabled (#3541 follow-up to #3528). Sending `reasoning_content` alone wasn't enough: Qwen3's chat template strips `<think>...</think>` from any assistant turn whose index is `<= last_query_index`, so the moment a new user message (the user's next prompt, or the auto-learn capture-at-stop nudge) lands, every prior assistant turn becomes "older" and is re-rendered without the `<think>` block — diverging from the generation tokens still in the slot's KV cache. The chat-completions encoder now emits `preserve_thinking: true` for Qwen thinking dialects on local servers, route-split the same way the existing `enable_thinking` emission is: the `qwen` dialect rides the top-level field (llama.cpp's `--jinja` hook and Alibaba Cloud Model Studio's compatible-mode), the `qwen-chat-template` dialect (NVIDIA NIM, vLLM/SGLang's chat-template-kwargs path) rides only `chat_template_kwargs.preserve_thinking` because NIM's request schema is `additionalProperties: false` and rejects unknown top-level fields (#2299). The emission is hoisted above the `reasoning.enabled` gate so it fires for THREE cases the original gating missed: (1) runtime-discovered local Qwen models that ship with `reasoning: false` because the upstream `/v1/models` doesn't advertise the capability (same gotcha #3532 fixed for `replayReasoningContent`), (2) caller-disabled reasoning (`/think off`) — the kwarg is a history-rendering knob, not a per-turn thinking switch, and the slot still holds `<think>` tokens from earlier turns, and (3) forced-tool-choice / DeepSeek-style auto-disable. Qwen3.6+ then renders `<think>...</think>` for every assistant turn regardless of position, and the next-turn render matches the cached generation tokens. ([#3541](https://github.com/can1357/oh-my-pi/issues/3541))
+
+## [16.1.22] - 2026-06-26
+
+### Fixed
+
+- Fixed llama.cpp / LM Studio / vLLM (and any local OpenAI-compatible server on a loopback or RFC1918 baseUrl) re-processing the full prompt on every assistant continuation when the prior turn produced `reasoning_content`: the `openai-completions` encoder dropped the preserved `thinking` block on re-serialization for compat profiles without `requiresReasoningContentForToolCalls` / `thinkingFormat: "zai"`, so the chat template re-rendered the assistant turn without `<think>…</think>` and the rendered tokens diverged from the slot's KV cache state. The auto-learn capture-at-stop nudge made it reproduce on every turn. The encoder now replays preserved thinking as `reasoning_content` (honoring the streamed signature when it identifies a recognized wire field — `reasoning_content` / `reasoning` / `reasoning_text` — and falling back to the configured `reasoningContentField` for opaque signatures) whenever the new `compat.replayReasoningContent` flag is set, and the cross-API `transformMessages` predicate (`openAICompletionsReplaysUnsignedThinking`) honors the same flag ahead of the `model.reasoning` gate so a switch into a discovered local target (where the spec carries `reasoning: false` because the upstream `/models` endpoints don't advertise the capability) still preserves the prior turn's thinking block as signature-stripped reasoning instead of demoting it to conversation text. The chat-template-rendered prefix stays byte-stable across turns and llama.cpp's prefix KV cache survives. ([#3528](https://github.com/can1357/oh-my-pi/issues/3528))
+
 ## [16.1.21] - 2026-06-26
 
 ### Fixed

package/dist/types/providers/openai-shared.d.ts

@@ -194,8 +194,10 @@ export type OpenAICompletionsParams = Omit<ChatCompletionCreateParamsStreaming,
         keep?: "all";
     };
     enable_thinking?: boolean;
+    preserve_thinking?: boolean;
     chat_template_kwargs?: {
-        enable_thinking: boolean;
+        enable_thinking?: boolean;
+        preserve_thinking?: boolean;
     };
     reasoning?: {
         effort?: string;

package/dist/types/registry/api-key-login.d.ts

@@ -22,6 +22,7 @@ type ModelsEndpointValidation = {
     kind: "models-endpoint";
     provider: string;
     modelsUrl: string;
+    headers?: Record<string, string> | (() => Record<string, string> | undefined);
 };
 export type ApiKeyLoginConfig = {
     /** Display name used in error messages, e.g. "Cerebras", "NanoGPT". */

package/dist/types/registry/api-key-validation.d.ts

@@ -19,6 +19,7 @@ type ModelListValidationOptions = {
     provider: string;
     apiKey: string;
     modelsUrl: string;
+    headers?: Record<string, string> | (() => Record<string, string> | undefined);
     signal?: AbortSignal;
     fetch?: FetchImpl;
 };

package/dist/types/registry/coreweave.d.ts

@@ -0,0 +1,7 @@
+import type { OAuthLoginCallbacks } from "./oauth/types";
+export declare const loginCoreWeave: (options: import("./oauth").OAuthController) => Promise<string>;
+export declare const coreWeaveProvider: {
+    readonly id: "coreweave";
+    readonly name: "CoreWeave Serverless Inference";
+    readonly login: (cb: OAuthLoginCallbacks) => Promise<string>;
+};

package/dist/types/registry/registry.d.ts

@@ -37,6 +37,10 @@ declare const ALL: ({
     readonly id: "cloudflare-ai-gateway";
     readonly name: "Cloudflare AI Gateway";
     readonly login: (cb: import("./oauth").OAuthLoginCallbacks) => Promise<string>;
+} | {
+    readonly id: "coreweave";
+    readonly name: "CoreWeave Serverless Inference";
+    readonly login: (cb: import("./oauth").OAuthLoginCallbacks) => Promise<string>;
 } | {
     readonly id: "cursor";
     readonly name: "Cursor (Claude, GPT, etc.)";

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-ai",
-	"version": "16.1.21",
+	"version": "16.1.23",
 	"description": "Unified LLM API with automatic model discovery and provider configuration",
 	"homepage": "https://omp.sh",
 	"author": "Can Boluk",
@@ -38,9 +38,9 @@
 	},
 	"dependencies": {
 		"@bufbuild/protobuf": "^2.12.0",
-		"@oh-my-pi/pi-catalog": "16.1.21",
-		"@oh-my-pi/pi-utils": "16.1.21",
-		"@oh-my-pi/pi-wire": "16.1.21",
+		"@oh-my-pi/pi-catalog": "16.1.23",
+		"@oh-my-pi/pi-utils": "16.1.23",
+		"@oh-my-pi/pi-wire": "16.1.23",
 		"arktype": "^2.2.0",
 		"zod": "^4"
 	},

package/src/providers/openai-completions.ts

@@ -1805,6 +1805,29 @@ export function convertMessages(
 					// signature on cross-API replays before the block reaches us.
 					const reasoningField = compat.reasoningContentField ?? "reasoning_content";
 					assistantMsg[reasoningField] = nonEmptyThinkingBlocks.map(b => b.thinking).join("\n");
+				} else if (compat.replayReasoningContent) {
+					// Local llama.cpp-style servers (llama.cpp, LM Studio, vLLM, Ollama
+					// in openai-completions mode, custom providers pointed at a
+					// loopback baseUrl) re-tokenize the entire prompt every request.
+					// Qwen3 / DeepSeek-R1 / GLM chat templates reconstruct the prior
+					// assistant turn's `<think>` block from `reasoning_content`; if we
+					// drop the field the template re-renders the assistant turn
+					// without thinking content, the rendered tokens diverge from the
+					// slot's existing KV cache, and llama.cpp falls back to full
+					// prompt re-processing (#3528). Honor the streamed signature when
+					// it identifies a recognized wire field so a model that emitted
+					// `reasoning` (some llama.cpp builds) round-trips to the same
+					// field; otherwise fall back to the configured
+					// `reasoningContentField`. Gated by the new compat flag rather
+					// than the existing `requires*` flags because local servers
+					// accept but don't validate the field — they just need it to
+					// preserve cache locality.
+					const signature = nonEmptyThinkingBlocks[0].thinkingSignature;
+					const reasoningField: OpenAICompletionsReasoningField =
+						signature === "reasoning_content" || signature === "reasoning" || signature === "reasoning_text"
+							? signature
+							: (compat.reasoningContentField ?? "reasoning_content");
+					assistantMsg[reasoningField] = nonEmptyThinkingBlocks.map(b => b.thinking).join("\n");
 				}
 			}
 

package/src/providers/openai-shared.ts

@@ -13,6 +13,11 @@ import type {
 	ResolvedOpenAISharedCompat,
 	VercelGatewayRouting,
 } from "@oh-my-pi/pi-catalog/types";
+import {
+	COREWEAVE_PROJECT_HEADER,
+	coreWeaveProjectHeaders,
+	hasCoreWeaveProjectHeader,
+} from "@oh-my-pi/pi-catalog/wire/coreweave";
 import { parseGitHubCopilotApiKey } from "@oh-my-pi/pi-catalog/wire/github-copilot";
 import { $env, extractHttpStatusFromError, logger, structuredCloneJSON } from "@oh-my-pi/pi-utils";
 import {
@@ -141,6 +146,16 @@ function resolveSakanaRequestBaseUrl(): string | undefined {
 	return normalizeSakanaRequestBaseUrl($env.SAKANA_BASE_URL) ?? normalizeSakanaRequestBaseUrl($env.FUGU_BASE_URL);
 }
 
+function applyCoreWeaveProjectHeader(headers: Record<string, string>): void {
+	if (hasCoreWeaveProjectHeader(headers)) {
+		return;
+	}
+	const projectHeaders = coreWeaveProjectHeaders($env);
+	if (projectHeaders) {
+		headers[COREWEAVE_PROJECT_HEADER] = projectHeaders[COREWEAVE_PROJECT_HEADER];
+	}
+}
+
 export function resolveOpenAIRequestSetup(
 	model: OpenAIRequestSetupModel,
 	options: OpenAIRequestSetupOptions,
@@ -160,6 +175,9 @@ export function resolveOpenAIRequestSetup(
 		Object.assign(headers, getOpenRouterHeaders());
 	}
 	Object.assign(headers, options.extraHeaders);
+	if (model.provider === "coreweave") {
+		applyCoreWeaveProjectHeader(headers);
+	}
 	if (options.prependHeaders) {
 		headers = { ...options.prependHeaders(), ...headers };
 	}
@@ -585,7 +603,8 @@ export type OpenAICompletionsParams = Omit<ChatCompletionCreateParamsStreaming,
 	repetition_penalty?: number;
 	thinking?: { type: "enabled" | "disabled"; keep?: "all" };
 	enable_thinking?: boolean;
-	chat_template_kwargs?: { enable_thinking: boolean };
+	preserve_thinking?: boolean;
+	chat_template_kwargs?: { enable_thinking?: boolean; preserve_thinking?: boolean };
 	reasoning?: { effort?: string } | { enabled: false };
 	reasoning_effort?: string | null;
 	service_tier?: ResolvedServiceTier;
@@ -813,6 +832,50 @@ function encodeChatCompletionsDisabledReasoning(
 }
 
 export function applyChatCompletionsCompatPolicy(params: OpenAICompletionsParams, policy: OpenAICompatPolicy): void {
+	// `preserve_thinking` is a chat-template HISTORY knob, not a per-turn
+	// thinking switch — it controls whether OLDER assistant turns render
+	// with `<think>...</think>` on Qwen3.6+. Emit it BEFORE the reasoning
+	// state branches and EVERY early-return below, because the wire shape
+	// must carry the kwarg in three cases the auto-detected
+	// `qwenPreserveThinking` flag covers but `reasoning.enabled` does not:
+	//
+	// 1. Discovered local Qwen models. `discoverOpenAICompatibleModels`
+	//    stamps `reasoning: false` on every spec built from a generic
+	//    `/v1/models` endpoint (the upstream doesn't advertise the
+	//    capability), so `model.reasoning === false` → `reasoning.enabled
+	//    === false`, the body wouldn't otherwise see the kwarg, and the
+	//    encoder's `replayReasoningContent` branch would keep shipping
+	//    `reasoning_content` only for the template to strip `<think>` from
+	//    older turns anyway. Exactly the #3528 / #3541 symptom on every
+	//    discovered Qwen build.
+	// 2. Caller-disabled reasoning. The slot's KV cache still holds prior
+	//    `<think>...</think>` tokens from earlier thinking turns; the
+	//    template must keep rendering them or cache invalidates at the
+	//    first historic `<think>`.
+	// 3. Forced-tool-choice / DeepSeek-style auto-disable. Same reasoning
+	//    as (2) — historic thinking blocks have to survive history replay
+	//    even when the current turn cannot think.
+	//
+	// Non-Qwen templates ignore the parameter (jinja `is defined` check
+	// silently no-ops), so emitting it unconditionally for the Qwen-family
+	// + local-cache compat flag is safe.
+	if (policy.compat.qwenPreserveThinking) {
+		// Mirror the dialect split that gates `enable_thinking`. The
+		// `qwen` dialect rides the top-level field (the only place
+		// llama.cpp's `--jinja` hook AND Alibaba Cloud Model Studio's
+		// compatible-mode look) while the `qwen-chat-template` dialect
+		// (NVIDIA NIM, vLLM/SGLang's chat-template-kwargs path) MUST
+		// ride only the kwargs copy — NIM's request schema is
+		// `additionalProperties: false` and rejects every unknown
+		// top-level field, the very reason `enable_thinking` is
+		// route-split this way (#2299, see `catalog/src/compat/openai.ts`
+		// thinkingFormat comment).
+		if (policy.compat.thinkingFormat === "qwen") {
+			params.preserve_thinking = true;
+		}
+		params.chat_template_kwargs = { ...params.chat_template_kwargs, preserve_thinking: true };
+	}
+
 	const reasoning = policy.reasoning;
 	if ((!reasoning.modelSupported && !reasoning.disabled) || !reasoning.supportsParams) return;
 	if (reasoning.enabled) {
@@ -832,7 +895,10 @@ export function applyChatCompletionsCompatPolicy(params: OpenAICompletionsParams
 				params.enable_thinking = true;
 				break;
 			case "qwen-template-false":
-				params.chat_template_kwargs = { enable_thinking: true };
+				// Spread so the `preserve_thinking` kwarg hoisted above
+				// survives the merge — a bare `{ enable_thinking: true }`
+				// would clobber it.
+				params.chat_template_kwargs = { ...params.chat_template_kwargs, enable_thinking: true };
 				break;
 			case "openrouter-enabled-false":
 				if (reasoning.wireEffort !== undefined) {

package/src/providers/transform-messages.ts

@@ -253,9 +253,20 @@ function isAnthropicMessagesModel(model: Model): model is Model<"anthropic-messa
  * branch.
  */
 function openAICompletionsReplaysUnsignedThinking(model: Model, compat: Model["compat"]): boolean {
-	if (model.api !== "openai-completions" || !model.reasoning) return false;
+	if (model.api !== "openai-completions") return false;
 	if (compat === undefined || !("requiresReasoningContentForToolCalls" in compat)) return false;
 	if (compat.requiresThinkingAsText) return false;
+	// Local llama.cpp-style servers (`replayReasoningContent`) need the replay
+	// for KV-cache prefix reuse — Qwen3 / DeepSeek-R1 / GLM chat templates
+	// reconstruct the prior turn's `<think>` block from `reasoning_content`
+	// (#3528). Checked BEFORE the `model.reasoning` gate: the runtime discovery
+	// paths for `llama.cpp` / `lm-studio` / `openai-models-list` hardcode
+	// `reasoning: false` even when the upstream actually emits reasoning, so
+	// gating on the spec flag here would let a cross-API switch into such a
+	// target demote the prior `thinking` block to text and lose the
+	// cache-stable prefix `replayReasoningContent` is meant to preserve.
+	if (compat.replayReasoningContent) return true;
+	if (!model.reasoning) return false;
 	// Hosts that REQUIRE `reasoning_content` on tool-call turns (DeepSeek
 	// reasoning, Kimi, OpenRouter reasoning, OpenCode thinking-on) already
 	// accept the replay; Z.AI-format hosts (Z.AI, Zhipu, Moonshot Kimi native,

package/src/registry/api-key-login.ts

@@ -31,6 +31,7 @@ type ModelsEndpointValidation = {
 	kind: "models-endpoint";
 	provider: string;
 	modelsUrl: string;
+	headers?: Record<string, string> | (() => Record<string, string> | undefined);
 };
 
 export type ApiKeyLoginConfig = {
@@ -98,6 +99,7 @@ export function createApiKeyLogin(config: ApiKeyLoginConfig): (options: OAuthCon
 					provider: config.validation.provider,
 					apiKey: trimmed,
 					modelsUrl: config.validation.modelsUrl,
+					headers: config.validation.headers,
 					signal: options.signal,
 					fetch: options.fetch,
 				});

package/src/registry/api-key-validation.ts

@@ -21,6 +21,7 @@ type ModelListValidationOptions = {
 	provider: string;
 	apiKey: string;
 	modelsUrl: string;
+	headers?: Record<string, string> | (() => Record<string, string> | undefined);
 	signal?: AbortSignal;
 	fetch?: FetchImpl;
 };
@@ -32,6 +33,12 @@ function normalizeAnthropicCompatibleBaseUrl(baseUrl: string): string {
 	return trimmed.endsWith("/v1") ? trimmed.slice(0, -3) : trimmed;
 }
 
+function resolveValidationHeaders(
+	headers: Record<string, string> | (() => Record<string, string> | undefined) | undefined,
+): Record<string, string> | undefined {
+	return typeof headers === "function" ? headers() : headers;
+}
+
 /**
  * Validate an API key against an OpenAI-compatible chat completions endpoint.
  *
@@ -129,6 +136,7 @@ export async function validateApiKeyAgainstModelsEndpoint(options: ModelListVali
 	const response = await fetchImpl(options.modelsUrl, {
 		method: "GET",
 		headers: {
+			...(resolveValidationHeaders(options.headers) ?? {}),
 			Authorization: `Bearer ${options.apiKey}`,
 		},
 		signal,

package/src/registry/coreweave.ts

@@ -0,0 +1,38 @@
+import { coreWeaveProjectHeaders } from "@oh-my-pi/pi-catalog/wire/coreweave";
+import { $env } from "@oh-my-pi/pi-utils";
+import { createApiKeyLogin } from "./api-key-login";
+import type { OAuthLoginCallbacks } from "./oauth/types";
+import type { ProviderDefinition } from "./types";
+
+const PROJECT_SETUP_INSTRUCTIONS =
+	"Create or select a CoreWeave Serverless Inference project, set COREWEAVE_PROJECT=<team>/<project> for the OpenAI-Project header, then copy your API key from account settings";
+
+function requireCoreWeaveProjectHeaders(): Record<string, string> {
+	const headers = coreWeaveProjectHeaders($env);
+	if (!headers) {
+		throw new Error(
+			"CoreWeave Serverless Inference requires OpenAI-Project. Set COREWEAVE_PROJECT=<team>/<project> before running /login coreweave.",
+		);
+	}
+	return headers;
+}
+
+export const loginCoreWeave = createApiKeyLogin({
+	providerLabel: "CoreWeave Serverless Inference",
+	authUrl: "https://wandb.ai/settings",
+	instructions: PROJECT_SETUP_INSTRUCTIONS,
+	promptMessage: "Paste your CoreWeave Serverless Inference API key",
+	placeholder: "api-key",
+	validation: {
+		kind: "models-endpoint",
+		provider: "CoreWeave Serverless Inference",
+		modelsUrl: "https://api.inference.wandb.ai/v1/models",
+		headers: requireCoreWeaveProjectHeaders,
+	},
+});
+
+export const coreWeaveProvider = {
+	id: "coreweave",
+	name: "CoreWeave Serverless Inference",
+	login: (cb: OAuthLoginCallbacks) => loginCoreWeave(cb),
+} as const satisfies ProviderDefinition;

package/src/registry/oauth/oauth.html

@@ -3,71 +3,150 @@
 	<head>
 		<meta charset="UTF-8" />
 		<meta name="viewport" content="width=device-width, initial-scale=1.0" />
-		<title>Authentication</title>
+		<title>oh my pi · authentication</title>
 		<style>
 			:root {
-				--bg: #09090b;
-				--card-bg: #18181b;
-				--text-main: #fafafa;
-				--text-muted: #a1a1aa;
-				--success: #22c55e;
-				--error: #ef4444;
-				--border: #27272a;
+				/* dark, slightly purple-tinted neutrals — never #000 */
+				--ink-0: oklch(0.135 0.018 295);
+				--ink-1: oklch(0.172 0.022 295);
+				--ink-2: oklch(0.21 0.024 295);
+				--ink-4: oklch(0.36 0.024 295);
+				--ink-5: oklch(0.5 0.022 290);
+				--ink-6: oklch(0.66 0.018 290);
+				--ink-7: oklch(0.82 0.014 285);
+				--ink-9: oklch(0.97 0.008 90);
+
+				/* brand: magenta lead, cyan reply */
+				--magenta: oklch(0.7 0.24 340);
+				--iris: oklch(0.62 0.21 295);
+				--cyan: oklch(0.81 0.14 200);
+
+				/* signal */
+				--success: oklch(0.78 0.16 150);
+				--error: oklch(0.66 0.22 25);
+
+				--bg: var(--ink-0);
+				--fg: var(--ink-9);
+				--fg-dim: var(--ink-7);
+				--fg-faint: var(--ink-5);
+				--rule: oklch(1 0 0 / 0.07);
+				--rule-strong: oklch(1 0 0 / 0.14);
+				--accent: var(--magenta);
+				--accent-2: var(--cyan);
+
+				color-scheme: dark;
+			}
+
+			* {
+				box-sizing: border-box;
 			}
+
 			body {
-				font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Helvetica, Arial, sans-serif;
-				background-color: var(--bg);
-				color: var(--text-main);
+				font-family: "Geist", ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif;
+				background:
+					radial-gradient(ellipse 80vw 60vh at 18% -10%, oklch(0.7 0.24 340 / 0.13), transparent 60%),
+					radial-gradient(ellipse 70vw 70vh at 110% 30%, oklch(0.81 0.14 200 / 0.09), transparent 60%),
+					var(--bg);
+				color: var(--fg);
 				display: flex;
 				align-items: center;
 				justify-content: center;
-				height: 100vh;
+				min-height: 100vh;
 				margin: 0;
-				overflow: hidden;
+				padding: 1.5rem;
+				-webkit-font-smoothing: antialiased;
+				text-rendering: optimizeLegibility;
+				overflow-x: clip;
 			}
+
+			/* ascii grid backdrop */
+			.grid-bg {
+				position: fixed;
+				inset: 0;
+				background-image:
+					linear-gradient(to right, oklch(1 0 0 / 0.025) 1px, transparent 1px),
+					linear-gradient(to bottom, oklch(1 0 0 / 0.025) 1px, transparent 1px);
+				background-size: 56px 56px;
+				background-position: -1px -1px;
+				mask-image: radial-gradient(ellipse at 50% 30%, #000 30%, transparent 75%);
+				pointer-events: none;
+				z-index: 0;
+			}
+
 			.container {
-				background: var(--card-bg);
-				border: 1px solid var(--border);
-				border-radius: 12px;
-				padding: 2.5rem;
+				position: relative;
+				z-index: 1;
+				background: oklch(0.172 0.022 295 / 0.72);
+				backdrop-filter: blur(16px);
+				-webkit-backdrop-filter: blur(16px);
+				border: 1px solid var(--rule);
+				border-radius: 16px;
+				padding: 2.5rem 2.5rem 2rem;
 				width: 100%;
-				max-width: 400px;
+				max-width: 420px;
 				text-align: center;
 				box-shadow:
-					0 20px 25px -5px rgba(0, 0, 0, 0.1),
-					0 10px 10px -5px rgba(0, 0, 0, 0.04);
+					0 24px 48px -12px oklch(0 0 0 / 0.55),
+					0 0 0 1px oklch(1 0 0 / 0.03) inset;
 				opacity: 0;
 				transform: translateY(10px);
-				animation: fadeIn 0.4s ease-out forwards;
+				animation: rise 0.6s cubic-bezier(0.16, 1, 0.3, 1) forwards;
 			}
-			@keyframes fadeIn {
+			@keyframes rise {
 				to {
 					opacity: 1;
-					transform: translateY(0);
+					transform: none;
 				}
 			}
-			.icon-circle {
-				position: relative;
-				width: 64px;
-				height: 64px;
-				border-radius: 50%;
+
+			/* brand header */
+			.brand {
 				display: flex;
 				align-items: center;
 				justify-content: center;
+				gap: 0.5rem;
+				margin-bottom: 2rem;
+			}
+			.brand svg {
+				width: 22px;
+				height: 22px;
+			}
+			.brand .wordmark {
+				font-size: 13px;
+				font-weight: 500;
+				letter-spacing: -0.01em;
+				color: var(--fg);
+			}
+
+			/* status mark */
+			.mark-wrap {
+				position: relative;
+				width: 72px;
+				height: 72px;
 				margin: 0 auto 1.5rem;
-				background: rgba(255, 255, 255, 0.05);
+				display: flex;
+				align-items: center;
+				justify-content: center;
 			}
-			.icon {
-				width: 32px;
-				height: 32px;
+			.mark-wrap::before {
+				content: "";
+				position: absolute;
+				inset: 0;
+				border-radius: 50%;
+				background: oklch(1 0 0 / 0.05);
+				z-index: 0;
+			}
+			.mark {
+				width: 40px;
+				height: 40px;
 				z-index: 2;
 			}
 			.timer-svg {
 				position: absolute;
 				top: -2px;
 				left: -2px;
-				width: 68px;
-				height: 68px;
+				width: 76px;
+				height: 76px;
 				transform: rotate(-90deg);
 				z-index: 1;
 				pointer-events: none;
@@ -76,7 +155,7 @@
 				fill: none;
 				stroke-width: 2;
 				stroke-linecap: round;
-				stroke-dasharray: 201;
+				stroke-dasharray: 226;
 				stroke-dashoffset: 0;
 			}
 			.countdown .timer-circle {
@@ -84,43 +163,55 @@
 			}
 			@keyframes countdown {
 				to {
-					stroke-dashoffset: 201;
+					stroke-dashoffset: 226;
 				}
 			}
+
 			h1 {
-				font-size: 1.5rem;
-				font-weight: 600;
+				font-family: "Fraunces", "Iowan Old Style", Georgia, serif;
+				font-size: 1.6rem;
+				font-weight: 500;
+				letter-spacing: -0.022em;
+				line-height: 1.15;
 				margin: 0 0 0.75rem;
-				letter-spacing: -0.025em;
+				text-wrap: balance;
 			}
 			p {
-				color: var(--text-muted);
-				line-height: 1.5;
-				margin: 0 0 1.5rem;
+				color: var(--fg-dim);
+				line-height: 1.6;
+				margin: 0 0 1.75rem;
 				font-size: 0.95rem;
 			}
+
 			.btn {
-				display: inline-block;
-				background: var(--text-main);
+				display: inline-flex;
+				align-items: center;
+				gap: 0.5rem;
+				background: var(--fg);
 				color: var(--bg);
+				font-family: inherit;
 				font-weight: 500;
-				padding: 0.6rem 1.2rem;
-				border-radius: 6px;
+				padding: 0.65rem 1.4rem;
+				border-radius: 8px;
 				text-decoration: none;
 				font-size: 0.9rem;
-				transition: opacity 0.2s;
+				transition: opacity 0.2s, transform 0.2s;
 				cursor: pointer;
 				border: none;
 			}
 			.btn:hover {
-				opacity: 0.9;
+				opacity: 0.88;
+				transform: translateY(-1px);
+			}
+			.btn:active {
+				transform: translateY(0);
 			}
 
 			/* State: success */
-			.success .icon-circle {
-				background: rgba(34, 197, 94, 0.1);
+			.success .mark-wrap::before {
+				background: oklch(0.78 0.16 150 / 0.12);
 			}
-			.success .icon {
+			.success .mark {
 				color: var(--success);
 			}
 			.success .timer-circle {
@@ -131,10 +222,10 @@
 			}
 
 			/* State: error */
-			.error .icon-circle {
-				background: rgba(239, 68, 68, 0.1);
+			.error .mark-wrap::before {
+				background: oklch(0.66 0.22 25 / 0.12);
 			}
-			.error .icon {
+			.error .mark {
 				color: var(--error);
 			}
 			.error .timer-circle {
@@ -144,21 +235,48 @@
 			.error .timer-svg {
 				display: none;
 			}
+
+			@media (prefers-reduced-motion: reduce) {
+				.container,
+				.countdown .timer-circle {
+					animation: none;
+				}
+				.container {
+					opacity: 1;
+					transform: none;
+				}
+			}
 		</style>
 	</head>
 	<body>
+		<span aria-hidden="true" class="grid-bg"></span>
 		<div id="app" class="container">
-			<div class="icon-circle">
-				<svg class="timer-svg" viewBox="0 0 68 68">
-					<circle class="timer-circle" cx="34" cy="34" r="32"></circle>
+			<div class="brand">
+				<svg viewBox="0 0 64 64" aria-hidden="true">
+					<defs>
+						<linearGradient id="pi-grad" x1="0" y1="0" x2="1" y2="1">
+							<stop offset="0" stop-color="oklch(0.7 0.24 340)" />
+							<stop offset=".5" stop-color="oklch(0.62 0.21 295)" />
+							<stop offset="1" stop-color="oklch(0.81 0.14 200)" />
+						</linearGradient>
+					</defs>
+					<path fill="url(#pi-grad)" d="M10 14h44v9H43v33h-9V23h-9v22h-9V23H10z" />
 				</svg>
-				<svg class="icon icon-success" fill="none" viewBox="0 0 24 24" stroke="currentColor" stroke-width="2">
+				<span class="wordmark">oh my pi</span>
+			</div>
+
+			<div class="mark-wrap">
+				<svg class="timer-svg" viewBox="0 0 76 76">
+					<circle class="timer-circle" cx="38" cy="38" r="36"></circle>
+				</svg>
+				<svg class="mark icon-success" fill="none" viewBox="0 0 24 24" stroke="currentColor" stroke-width="2">
 					<path stroke-linecap="round" stroke-linejoin="round" d="M5 13l4 4L19 7" />
 				</svg>
-				<svg class="icon icon-error" fill="none" viewBox="0 0 24 24" stroke="currentColor" stroke-width="2">
+				<svg class="mark icon-error" fill="none" viewBox="0 0 24 24" stroke="currentColor" stroke-width="2">
 					<path stroke-linecap="round" stroke-linejoin="round" d="M6 18L18 6M6 6l12 12" />
 				</svg>
 			</div>
+
 			<h1 id="title">Authentication</h1>
 			<p id="message"></p>
 			<button onclick="window.close()" class="btn">Close Window</button>

package/src/registry/registry.ts

@@ -6,6 +6,7 @@ import { anthropicProvider } from "./anthropic";
 import { azureProvider } from "./azure";
 import { cerebrasProvider } from "./cerebras";
 import { cloudflareAiGatewayProvider } from "./cloudflare-ai-gateway";
+import { coreWeaveProvider } from "./coreweave";
 import { cursorProvider } from "./cursor";
 import { deepseekProvider } from "./deepseek";
 import { devinProvider } from "./devin";
@@ -112,6 +113,7 @@ const ALL = [
 	syntheticProvider,
 	nanogptProvider,
 	waferServerlessProvider,
+	coreWeaveProvider,
 	vercelAiGatewayProvider,
 	cloudflareAiGatewayProvider,
 	litellmProvider,

package/src/utils/thinking-loop.ts

@@ -16,7 +16,7 @@
  * replay-unsafe and is never retried), so the turn is discarded and re-sampled
  * instead of committing the garbage transcript.
  *
- * Two failure shapes are detected:
+ * Three failure shapes are detected:
  * 1. **Verbatim tail repetition** — a short unit repeated back-to-back (e.g.
  *    "🌊 🌊 🌊 …"). Caught from a rolling 250-char tail.
  * 2. **Near-duplicate segments** — paragraphs that normalize to the same
@@ -24,6 +24,12 @@
  *    paragraphs. Thresholds were calibrated on a real loop transcript plus
  *    13.5k non-loop thinking blocks (zero false positives; hardest negative
  *    scored 3 against the trigger of 4).
+ * 3. **Progress-lexicon stall** — paragraphs that keep reshuffling the same
+ *    motivational filler ("just doing it, pushing ahead, maintaining momentum")
+ *    into fresh word order, so trigrams never match, yet introduce no new
+ *    vocabulary and name nothing concrete. Caught by a run of low-novelty,
+ *    anchor-free segments; a segment naming a path/identifier resets the run, so
+ *    genuine but vocabulary-repetitive work (per-file templates) is spared.
  *
  * Scope is narrow: guarded Gemini/DeepSeek streams before any tool call. Native
  * thinking is checked first; assistant text can also be checked for providers
@@ -63,6 +69,32 @@ const SEGMENT_MIN_COUNT = 8;
 /** Near-duplicate cluster size (current + matches) that trips the loop. */
 const SEGMENT_MIN_CLUSTER = 4;
 
+/** Recent segments whose pooled unigram vocabulary is the novelty baseline for
+ *  progress-lexicon stall detection. */
+const LEX_NOVELTY_WINDOW = 8;
+/** Novelty (fraction of a segment's content words unseen across the recent
+ *  window) at/below which a segment counts as recycling earlier wording.
+ *  Calibrated against 536k real non-Gemini reasoning blocks: at 0.2 the longest
+ *  low-information run any legitimate block reached was 7. */
+const LEX_STALL_NOVELTY_FLOOR = 0.2;
+/** Consecutive low-information segments that trip a progress-lexicon stall. Set
+ *  to 8 (one above the worst legitimate run observed in the 536k-block corpus) so
+ *  the heuristic stays clear of focused reasoning that briefly recycles wording;
+ *  the real reasoning-summarizer loop sustains far longer runs (10+). */
+const LEX_STALL_MIN_RUN = 8;
+
+/** A concrete reference the model is actually reasoning about: a code span, a
+ *  file extension / dotted member, a multi-segment path, or a snake/camel/Pascal
+ *  identifier. A segment that introduces a NEW one resets the lexical-stall run —
+ *  this spares genuine per-target work (per-file templates, focused single-symbol
+ *  debugging) while still catching reworded filler that names nothing new ("just
+ *  doing it, pushing ahead") or fixates on one unchanging reference. Excludes bare
+ *  digits, abbreviations, and decimals (e.g. "Step 2", "i.e.", "1.2") so numbered
+ *  or punctuated filler is not self-anchoring. Global flag: collected with
+ *  matchAll, so never used with the stateful test(). */
+const CONCRETE_ANCHOR =
+	/`[^`]+`|\b\w{2,}\.[a-zA-Z]\w{0,4}\b|[\w-]+(?:\/[\w-]+){2,}|\b\w+_\w+\b|\b[a-z]+[A-Z]\w*\b|\b[A-Z][a-z]+[A-Z]\w*\b/g;
+
 const OPENAI_COMPAT_GUARDED_APIS: Partial<Record<Api, true>> = {
 	"openai-completions": true,
 	"openai-responses": true,
@@ -113,6 +145,15 @@ export class ThinkingLoopDetector {
 	#window: Set<string>[] = [];
 	/** Count of substantial segments seen so far (warm-up gate). */
 	#count = 0;
+	/** Unigram word sets of the most recent segments (≤ LEX_NOVELTY_WINDOW); the
+	 *  novelty baseline for progress-lexicon stall detection. */
+	#wordWindow: Set<string>[] = [];
+	/** Consecutive low-information (low-novelty, anchor-free) segments seen. */
+	#lexStallRun = 0;
+	/** Concrete anchors seen per recent segment (≤ LEX_NOVELTY_WINDOW). A stall is
+	 *  only broken by a *new* reference, so filler repeating one fixed
+	 *  path/identifier every paragraph is still caught. */
+	#anchorWindow: Set<string>[] = [];
 
 	push(delta: string): string | null {
 		if (!delta) return null;
@@ -167,22 +208,71 @@ export class ThinkingLoopDetector {
 		return null;
 	}
 
-	#consumeSegment(segment: string): string | null {
+	#consumeSegment(raw: string): string | null {
+		// Reasoning-summarizer titles ("**Maintaining Momentum**", "## Heading")
+		// are per-thought formatting, not chain-of-thought; their ever-changing
+		// wording would otherwise mask a loop by inflating novelty. Strip them
+		// before analysis (a title-only segment then falls below the length gate).
+		const segment = raw.replace(/^[ \t]*#{1,6}[ \t].*$/gm, "").replace(/^[ \t]*\*{2,3}.+?\*{2,3}[ \t]*$/gm, "");
 		const normalized = normalizeSegment(segment);
 		if (normalized.length < SEGMENT_MIN_NORM_CHARS) return null;
 
+		// (a) Near-duplicate trigram cluster: the same paragraph reused with
+		// cosmetic wording drift (high word-trigram overlap).
 		const fingerprint = trigramShingles(normalized);
 		let cluster = 1;
 		for (const prev of this.#window) {
 			if (jaccard(fingerprint, prev) >= SEGMENT_SIMILARITY) cluster++;
 		}
 
+		// (b) Progress-lexicon stall: paragraphs that recycle the recent
+		// vocabulary (low novelty) and add no *new* concrete reference — reworded
+		// filler that burns budget without advancing. The trigram check above
+		// already claims high-overlap near-duplicates; this catches the
+		// low-overlap, reshuffled-wording shape it misses. Requiring a NEW anchor
+		// (not merely any anchor) still catches filler that name-drops one fixed
+		// path/identifier every paragraph, while sparing genuine per-target work
+		// that names a fresh file/symbol each time.
+		const words = new Set<string>(normalized.split(" ").filter(Boolean));
+		const priorVocab = new Set<string>();
+		for (const set of this.#wordWindow) for (const w of set) priorVocab.add(w);
+		let unseen = 0;
+		for (const w of words) if (!priorVocab.has(w)) unseen++;
+		const novelty = priorVocab.size === 0 ? 1 : unseen / words.size;
+
+		const anchors = new Set<string>();
+		// Canonicalize so the same reference written as `Foo`, Foo, or FOO is one
+		// anchor and cannot masquerade as "new" to keep a fixed-reference stall alive.
+		for (const match of segment.matchAll(CONCRETE_ANCHOR)) anchors.add(match[0].replace(/`/g, "").toLowerCase());
+		let newAnchor = false;
+		for (const anchor of anchors) {
+			if (this.#anchorWindow.every(seen => !seen.has(anchor))) {
+				newAnchor = true;
+				break;
+			}
+		}
+
+		if (novelty <= LEX_STALL_NOVELTY_FLOOR && !newAnchor) {
+			this.#lexStallRun++;
+		} else {
+			this.#lexStallRun = 0;
+		}
+
 		this.#window.push(fingerprint);
 		if (this.#window.length > SEGMENT_WINDOW) this.#window.shift();
+		this.#wordWindow.push(words);
+		if (this.#wordWindow.length > LEX_NOVELTY_WINDOW) this.#wordWindow.shift();
+		this.#anchorWindow.push(anchors);
+		if (this.#anchorWindow.length > LEX_NOVELTY_WINDOW) this.#anchorWindow.shift();
 		this.#count++;
 
-		if (this.#count >= SEGMENT_MIN_COUNT && cluster >= SEGMENT_MIN_CLUSTER) {
-			return `${cluster} near-identical segments within the last ${SEGMENT_WINDOW}`;
+		if (this.#count >= SEGMENT_MIN_COUNT) {
+			if (cluster >= SEGMENT_MIN_CLUSTER) {
+				return `${cluster} near-identical segments within the last ${SEGMENT_WINDOW}`;
+			}
+			if (this.#lexStallRun >= LEX_STALL_MIN_RUN) {
+				return `${this.#lexStallRun} low-information segments recycling recent wording`;
+			}
 		}
 		return null;
 	}