@oh-my-pi/pi-coding-agent 16.0.1 → 16.0.3

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "16.0.1",
+	"version": "16.0.3",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://omp.sh",
 	"author": "Can Boluk",
@@ -47,17 +47,17 @@
 		"@agentclientprotocol/sdk": "0.25.0",
 		"@babel/parser": "^7.29.7",
 		"@mozilla/readability": "^0.6.0",
-		"@oh-my-pi/hashline": "16.0.1",
-		"@oh-my-pi/omp-stats": "16.0.1",
-		"@oh-my-pi/pi-agent-core": "16.0.1",
-		"@oh-my-pi/pi-ai": "16.0.1",
-		"@oh-my-pi/pi-catalog": "16.0.1",
-		"@oh-my-pi/pi-mnemopi": "16.0.1",
-		"@oh-my-pi/pi-natives": "16.0.1",
-		"@oh-my-pi/pi-tui": "16.0.1",
-		"@oh-my-pi/pi-utils": "16.0.1",
-		"@oh-my-pi/pi-wire": "16.0.1",
-		"@oh-my-pi/snapcompact": "16.0.1",
+		"@oh-my-pi/hashline": "16.0.3",
+		"@oh-my-pi/omp-stats": "16.0.3",
+		"@oh-my-pi/pi-agent-core": "16.0.3",
+		"@oh-my-pi/pi-ai": "16.0.3",
+		"@oh-my-pi/pi-catalog": "16.0.3",
+		"@oh-my-pi/pi-mnemopi": "16.0.3",
+		"@oh-my-pi/pi-natives": "16.0.3",
+		"@oh-my-pi/pi-tui": "16.0.3",
+		"@oh-my-pi/pi-utils": "16.0.3",
+		"@oh-my-pi/pi-wire": "16.0.3",
+		"@oh-my-pi/snapcompact": "16.0.3",
 		"@opentelemetry/api": "^1.9.1",
 		"@opentelemetry/context-async-hooks": "^2.7.1",
 		"@opentelemetry/exporter-trace-otlp-proto": "^0.218.0",

package/src/advisor/__tests__/advisor.test.ts

@@ -8,10 +8,12 @@ import {
 	ADVISOR_READONLY_TOOL_NAMES,
 	AdviseTool,
 	type AdvisorAgent,
+	type AdvisorNote,
 	AdvisorRuntime,
 	type AdvisorRuntimeHost,
 	formatAdvisorBatchContent,
 	isInterruptingSeverity,
+	resolveAdvisorDeliveryChannel,
 } from "..";
 
 describe("advisor", () => {
@@ -51,7 +53,7 @@ describe("advisor", () => {
 				},
 				scheduleIdleFlush: () => {},
 			});
-			yq.register<{ note: string; severity?: "nit" | "concern" | "blocker" }>("advisor", {
+			yq.register<AdvisorNote>("advisor", {
 				build: entries =>
 					entries.length === 0
 						? null
@@ -61,9 +63,7 @@ describe("advisor", () => {
 								display: true,
 								attribution: "agent",
 								timestamp: Date.now(),
-								content:
-									"Advisor (a senior reviewer watching your work — weigh it, don't blindly obey):\n" +
-									entries.map(e => `- ${e.severity ? `[${e.severity}] ` : ""}${e.note}`).join("\n"),
+								content: formatAdvisorBatchContent(entries),
 							} as AgentMessage),
 			});
 
@@ -76,8 +76,9 @@ describe("advisor", () => {
 			expect(msg.role).toBe("custom");
 			expect(msg.customType).toBe("advisor");
 			expect(msg.display).toBe(true);
-			expect(msg.content).toContain("[blocker] second note");
-			expect(msg.content).toContain("- first note");
+			expect(msg.content).toContain("second note");
+			expect(msg.content).toContain('severity="blocker"');
+			expect(msg.content).toContain("first note");
 		});
 
 		it("skipIdleFlush prevents idle scheduling", () => {
@@ -123,15 +124,21 @@ describe("advisor", () => {
 			expect(isInterruptingSeverity(undefined)).toBe(false);
 		});
 
-		it("formats a batch with the advisor prefix and severity-tagged bullets", () => {
+		it("wraps each note in an advisory tag with severity as an attribute and escapes the body", () => {
 			const content = formatAdvisorBatchContent([
 				{ note: "first note" },
-				{ note: "second note", severity: "blocker" },
+				{ note: "second <note> & more", severity: "blocker" },
 			]);
-			const lines = content.split("\n");
-			expect(lines[0]).toContain("senior reviewer");
-			expect(lines[1]).toBe("- first note");
-			expect(lines[2]).toBe("- [blocker] second note");
+			// No-severity note: bare advisory tag (no severity attribute).
+			expect(content).toMatch(/<advisory guidance="[^"]*">\nfirst note\n<\/advisory>/);
+			// Severity rides an attribute, not an inline `[blocker]` tag or a bullet.
+			expect(content).toMatch(/<advisory severity="blocker" guidance="[^"]*">/);
+			expect(content).not.toContain("[blocker]");
+			expect(content).not.toContain("- first note");
+			// XML-significant characters in the body are escaped so they can't break the tag.
+			expect(content).toContain("second &lt;note&gt; &amp; more");
+			// Exactly one severity attribute (only the blocker note carries one).
+			expect(content.split('severity="').length - 1).toBe(1);
 		});
 	});
 
@@ -278,6 +285,56 @@ describe("advisor", () => {
 			expect(promptInputs[0]).not.toContain("note");
 		});
 
+		it("renders the watched delta with a heading, watched-role labels, and no inner ## headings", () => {
+			const promptInputs: string[] = [];
+			const agent = makeAgent(promptInputs);
+			const messages: AgentMessage[] = [
+				{ role: "user", content: "do the thing", timestamp: 1 } as AgentMessage,
+				{
+					role: "assistant",
+					content: [{ type: "toolCall", id: "a", name: "read", arguments: { path: "x.ts" } }],
+					timestamp: 2,
+				} as unknown as AgentMessage,
+				{
+					role: "toolResult",
+					toolCallId: "a",
+					toolName: "read",
+					content: [{ type: "text", text: "ok" }],
+					isError: false,
+					timestamp: 3,
+				} as AgentMessage,
+				{
+					role: "assistant",
+					content: [{ type: "toolCall", id: "b", name: "search", arguments: { pattern: "y" } }],
+					timestamp: 4,
+				} as unknown as AgentMessage,
+				{
+					role: "toolResult",
+					toolCallId: "b",
+					toolName: "search",
+					content: [{ type: "text", text: "ok" }],
+					isError: false,
+					timestamp: 5,
+				} as AgentMessage,
+			];
+			const host: AdvisorRuntimeHost = {
+				snapshotMessages: () => messages,
+				enqueueAdvice: () => {},
+			};
+			const runtime = new AdvisorRuntime(agent, host);
+			runtime.onTurnEnd();
+			expect(promptInputs).toHaveLength(1);
+			const prompt = promptInputs[0];
+			expect(prompt).toContain("### Session update");
+			expect(prompt).toContain("**user**:");
+			expect(prompt).toContain("**agent**:");
+			// Inner role headings would collide with the advisor's own turns in the dump.
+			expect(prompt).not.toContain("## assistant");
+			expect(prompt).not.toContain("## user");
+			// Consecutive assistant tool-call messages collapse under a single label.
+			expect(prompt.split("**agent**:").length - 1).toBe(1);
+		});
+
 		it("handles compaction shrink without prompting", () => {
 			const promptInputs: string[] = [];
 			const agent = makeAgent(promptInputs);
@@ -583,4 +640,91 @@ describe("advisor", () => {
 			expect(text).toContain("truncated.");
 		});
 	});
+
+	// Regression: the advisor must not withhold interrupting advice from a turn
+	// that is actively streaming again after a user interrupt. The latch only
+	// guards auto-resume of a stopped/idle run; parking a note mid-stream stranded
+	// it (the agent never heard it) and dumped the backlog as one burst at the next
+	// user prompt. See the 7-concern same-instant burst in session 019ed1dd.
+	//
+	// `streaming` here means the live agent-CORE loop (agent.state.isStreaming) —
+	// NOT session `isStreaming`, which also counts `#promptInFlightCount` during
+	// post-turn unwind. Only a running core loop consumes a steer; in the unwind
+	// window (`streaming: false`) a suppressed note must `preserve`, never `steer`,
+	// or it strands and #drainStrandedQueuedMessages auto-resumes it. Do not swap
+	// the call site back to session `isStreaming`.
+	describe("resolveAdvisorDeliveryChannel", () => {
+		it("routes a non-interrupting nit to the aside queue regardless of state", () => {
+			expect(
+				resolveAdvisorDeliveryChannel({
+					severity: "nit",
+					autoResumeSuppressed: true,
+					streaming: true,
+					aborting: true,
+				}),
+			).toBe("aside");
+			expect(
+				resolveAdvisorDeliveryChannel({
+					severity: undefined,
+					autoResumeSuppressed: false,
+					streaming: false,
+					aborting: false,
+				}),
+			).toBe("aside");
+		});
+
+		it("steers concern/blocker when no user interrupt is in effect", () => {
+			for (const severity of ["concern", "blocker"] as const) {
+				for (const streaming of [true, false]) {
+					expect(
+						resolveAdvisorDeliveryChannel({
+							severity,
+							autoResumeSuppressed: false,
+							streaming,
+							aborting: false,
+						}),
+					).toBe("steer");
+				}
+			}
+		});
+
+		it("preserves an interrupting note while suppressed AND idle (no auto-resume of a stopped run)", () => {
+			for (const severity of ["concern", "blocker"] as const) {
+				expect(
+					resolveAdvisorDeliveryChannel({
+						severity,
+						autoResumeSuppressed: true,
+						streaming: false,
+						aborting: false,
+					}),
+				).toBe("preserve");
+			}
+		});
+
+		it("preserves an interrupting note while suppressed AND aborting, even though the turn still reports streaming", () => {
+			// Mid-abort teardown: steering would land after #extractQueuedAdvisorCards
+			// and could auto-resume on the stranded steer. Keep parking it.
+			expect(
+				resolveAdvisorDeliveryChannel({
+					severity: "blocker",
+					autoResumeSuppressed: true,
+					streaming: true,
+					aborting: true,
+				}),
+			).toBe("preserve");
+		});
+
+		it("steers an interrupting note while suppressed once a turn is streaming again and not aborting (the fix)", () => {
+			for (const severity of ["concern", "blocker"] as const) {
+				expect(
+					resolveAdvisorDeliveryChannel({
+						severity,
+						autoResumeSuppressed: true,
+						streaming: true,
+						aborting: false,
+					}),
+				).toBe("steer");
+			}
+		});
+	});
 });

package/src/advisor/advise-tool.ts

@@ -1,4 +1,5 @@
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
+import { escapeXmlText } from "@oh-my-pi/pi-utils";
 import { z } from "zod/v4";
 import adviseDescription from "../prompts/advisor/advise-tool.md" with { type: "text" };
 
@@ -33,15 +34,26 @@ export interface AdvisorMessageDetails {
 }
 
 /**
- * Prose framing prepended to every batched advisor message. Kept here so the
- * non-interrupting YieldQueue dispatcher and the interrupting steer path build
- * byte-identical content.
+ * Behavioral framing for the watched agent — advice, not orders. Carried as a
+ * tag attribute (rather than a prose header) so the rendered agent-facing output
+ * stays a clean `<advisory>` block. The primary agent's system prompt never
+ * mentions advisories, so this is its only cue for how to treat them.
  */
-const ADVISOR_BATCH_PREFIX = "Advisor (a senior reviewer watching your work — weigh it, don't blindly obey):";
+const ADVISOR_GUIDANCE = "weigh, don't blindly obey";
 
-/** Render one advisor card body from a batch of notes (prefix + one bullet per note). */
+/**
+ * Render a batch of advisor notes as the agent-facing message body: one
+ * `<advisory>` element per note, severity as an attribute. Shared by the
+ * non-interrupting YieldQueue dispatcher and the interrupting steer path so both
+ * build byte-identical content.
+ */
 export function formatAdvisorBatchContent(notes: readonly AdvisorNote[]): string {
-	return `${ADVISOR_BATCH_PREFIX}\n${notes.map(n => `- ${n.severity ? `[${n.severity}] ` : ""}${n.note}`).join("\n")}`;
+	return notes
+		.map(n => {
+			const severity = n.severity ? ` severity="${n.severity}"` : "";
+			return `<advisory${severity} guidance="${ADVISOR_GUIDANCE}">\n${escapeXmlText(n.note)}\n</advisory>`;
+		})
+		.join("\n");
 }
 
 /**
@@ -54,6 +66,36 @@ export function isInterruptingSeverity(severity: AdvisorSeverity | undefined): b
 	return severity === "concern" || severity === "blocker";
 }
 
+/** How an advisor note is routed to the primary. */
+export type AdvisorDeliveryChannel = "aside" | "steer" | "preserve";
+
+/**
+ * Decide how one advisor note reaches the primary agent.
+ *
+ * - A non-interrupting `nit` always rides the non-interrupting aside queue.
+ * - An interrupting `concern`/`blocker` is normally steered into the agent: into
+ *   the live turn while one is streaming, or (when idle) a triggered turn so the
+ *   advice is acted on immediately.
+ * - After a deliberate user interrupt (`autoResumeSuppressed`) the advisor must
+ *   not auto-resume the stopped run. While the agent is idle — or still tearing
+ *   the interrupted turn down (`aborting`) — the note is preserved as a visible
+ *   card instead of restarting the run. But once a turn is actively streaming
+ *   again (a resume the user already drove), steering the note in does NOT
+ *   auto-resume anything, so it is delivered live. Parking it during an active
+ *   run instead strands it (it never reaches the running agent) and the withheld
+ *   notes dump as one burst at the next user prompt — the bug this guards.
+ */
+export function resolveAdvisorDeliveryChannel(opts: {
+	severity: AdvisorSeverity | undefined;
+	autoResumeSuppressed: boolean;
+	streaming: boolean;
+	aborting: boolean;
+}): AdvisorDeliveryChannel {
+	if (!isInterruptingSeverity(opts.severity)) return "aside";
+	if (opts.autoResumeSuppressed && (opts.aborting || !opts.streaming)) return "preserve";
+	return "steer";
+}
+
 /**
  * Side-effect-free investigation tools handed to the advisor agent so it can
  * inspect the workspace before weighing in. Names match the primary session's

package/src/advisor/runtime.ts

@@ -157,8 +157,13 @@ export class AdvisorRuntime {
 			.filter(m => !(m.role === "custom" && (m as { customType?: string }).customType === "advisor"));
 		this.#lastCount = all.length;
 		if (delta.length === 0) return null;
-		const md = formatSessionHistoryMarkdown(delta, { includeThinking: true, includeToolIntent: true });
-		return md.trim() ? md : null;
+		const md = formatSessionHistoryMarkdown(delta, {
+			includeThinking: true,
+			includeToolIntent: true,
+			watchedRoles: true,
+		});
+		if (!md.trim()) return null;
+		return `### Session update\n\n${md}`;
 	}
 
 	#notifyWaiters(): void {
@@ -182,7 +187,9 @@ export class AdvisorRuntime {
 		try {
 			while (!this.disposed && this.#pending.length) {
 				const popped = this.#pending.splice(0);
-				const candidateBatch = popped.map(b => b.text).join("\n\n---\n\n");
+				// Each delta already opens with a `### Session update` heading, so
+				// join with a blank line rather than a `---` rule.
+				const candidateBatch = popped.map(b => b.text).join("\n\n");
 				const turnsCovered = popped.reduce((sum, b) => sum + b.turns, 0);
 				const incomingTokens = estimateTokens({
 					role: "user",

package/src/auto-thinking/classifier.ts

@@ -22,7 +22,11 @@ import type { Settings } from "../config/settings";
 import difficultySystemPrompt from "../prompts/system/auto-thinking-difficulty.md" with { type: "text" };
 import difficultyLocalPrompt from "../prompts/system/auto-thinking-difficulty-local.md" with { type: "text" };
 import { clampAutoThinkingEffort } from "../thinking";
-import { isTinyMemoryLocalModelKey, ONLINE_AUTO_THINKING_MODEL_KEY } from "../tiny/models";
+import {
+	isTinyMemoryLocalModelKey,
+	isTinyMemoryReasoningModelKey,
+	ONLINE_AUTO_THINKING_MODEL_KEY,
+} from "../tiny/models";
 import { tinyModelClient } from "../tiny/title-client";
 
 const DIFFICULTY_SYSTEM_PROMPT = prompt.render(difficultySystemPrompt);
@@ -31,8 +35,10 @@ const DIFFICULTY_SYSTEM_PROMPT = prompt.render(difficultySystemPrompt);
 const MAX_INPUT_CHARS = 6000;
 const HEAD_CHARS = 4000;
 const TAIL_CHARS = 2000;
-/** The answer is a single word; keep budgets tiny for non-reasoning backends. */
+/** The online answer is a single word; keep budgets tiny for non-reasoning backends. */
 const ANSWER_MAX_TOKENS = 8;
+/** Local classifiers occasionally need more room for chat-template boilerplate. */
+const LOCAL_ANSWER_MAX_TOKENS = 16;
 /**
  * Reasoning backends ignore `disableReasoning` on some providers, so reserve
  * enough output room for the keyword to still land after unavoidable thinking.
@@ -107,9 +113,12 @@ async function classifyLocal(input: string, modelKey: string, deps: ClassifyDiff
 	if (!isTinyMemoryLocalModelKey(modelKey)) {
 		throw new Error(`auto-thinking: unsupported local classifier model: ${modelKey}`);
 	}
+	const maxTokens = isTinyMemoryReasoningModelKey(modelKey)
+		? Math.max(LOCAL_ANSWER_MAX_TOKENS, REASONING_SAFE_MAX_TOKENS)
+		: LOCAL_ANSWER_MAX_TOKENS;
 	const builtPrompt = prompt.render(difficultyLocalPrompt, { prompt: input });
 	const text = await tinyModelClient.complete(modelKey, builtPrompt, {
-		maxTokens: ANSWER_MAX_TOKENS,
+		maxTokens,
 		signal: deps.signal,
 	});
 	if (!text) {

package/src/cli/args.ts

@@ -280,6 +280,7 @@ export function getExtraHelpText(): string {
   MISTRAL_API_KEY            - Mistral models
   ZAI_API_KEY                - z.ai models (ZhipuAI/GLM)
   UMANS_AI_CODING_PLAN_API_KEY - Umans AI Coding Plan models
+  UMANS_WEBSEARCH_PROVIDER    - Umans gateway web search backend (native or exa)
   MINIMAX_API_KEY            - MiniMax models
   OPENCODE_API_KEY           - OpenCode Zen/OpenCode Go models
   CURSOR_ACCESS_TOKEN        - Cursor AI models

package/src/cli.ts

@@ -109,8 +109,8 @@ async function runWorkerEntrypoint(arg: string | undefined): Promise<boolean> {
 		// this dispatch completes — so anything the parent posted right after
 		// spawning (the smoke ping, the first parse request) would be dropped.
 		// Park early events and replay them once the module's handler is live.
-		// (The tab/eval workers are immune: `parentPort.on("message")` queues
-		// until a listener attaches.)
+		// Worker-thread entries using `parentPort` need the same sync-prefix
+		// buffering; the tab/eval cases install that inbox below before import.
 		const scope = globalThis as unknown as { onmessage: ((event: MessageEvent) => void) | null };
 		const pending: MessageEvent[] = [];
 		const buffer = (event: MessageEvent): void => {

package/src/commands/install.ts

@@ -28,13 +28,13 @@ import { initTheme } from "../modes/theme/theme";
  * Heuristic used to decide whether `omp install <target>` should `link` a
  * local directory or `install` a remote spec. Exported for tests.
  */
-export function looksLikeLocalPath(target: string): boolean {
+export function looksLikeLocalPath(target: string, cwd?: string): boolean {
 	if (target.startsWith(".") || target.startsWith("/") || target.startsWith("~")) return true;
 	// Windows drive prefix (e.g. `C:\foo`).
 	if (/^[a-zA-Z]:[\\/]/.test(target)) return true;
-	// Bare names that happen to exist as a local directory.
+	// Bare names that happen to exist as a local directory (relative to `cwd`).
 	try {
-		return existsSync(path.resolve(target));
+		return existsSync(cwd ? path.resolve(cwd, target) : path.resolve(target));
 	} catch {
 		return false;
 	}

package/src/config/model-resolver.ts

@@ -34,17 +34,36 @@ import { isAuthenticated, kNoAuth, type ModelRegistry } from "./model-registry";
 import { MODEL_ROLE_IDS, type ModelRole } from "./model-roles";
 import type { Settings } from "./settings";
 
+function isKnownProvider(provider: string): provider is KnownProvider {
+	return provider in DEFAULT_MODEL_PER_PROVIDER;
+}
+
 /**
- * Pick the first available model matching a known provider's default id
- * (catalog table order), falling back to the first available model.
+ * Pick the first provider-default model in availability order.
+ *
+ * If multiple providers expose that same default id, rank only that shared-id
+ * group by canonical provider priority so native/OAuth transports beat mirrors
+ * without changing unrelated provider fallback precedence.
  */
-function pickDefaultAvailableModel(availableModels: Model<Api>[]): Model<Api> | undefined {
-	for (const provider of Object.keys(DEFAULT_MODEL_PER_PROVIDER) as KnownProvider[]) {
-		const defaultId = DEFAULT_MODEL_PER_PROVIDER[provider];
-		const match = availableModels.find(m => m.provider === provider && m.id === defaultId);
-		if (match) return match;
-	}
-	return availableModels[0];
+export function pickDefaultAvailableModel(availableModels: Model<Api>[]): Model<Api> | undefined {
+	const firstDefault = availableModels.find(
+		model => isKnownProvider(model.provider) && DEFAULT_MODEL_PER_PROVIDER[model.provider] === model.id,
+	);
+	if (!firstDefault) return availableModels[0];
+
+	const providerPriority = buildModelProviderPriorityRank();
+	const sharedDefaultMatches = availableModels.filter(
+		model =>
+			model.id === firstDefault.id &&
+			isKnownProvider(model.provider) &&
+			DEFAULT_MODEL_PER_PROVIDER[model.provider] === model.id,
+	);
+	return [...sharedDefaultMatches].sort((a, b) => {
+		const aRank = providerPriority.get(a.provider.toLowerCase()) ?? Number.POSITIVE_INFINITY;
+		const bRank = providerPriority.get(b.provider.toLowerCase()) ?? Number.POSITIVE_INFINITY;
+		if (aRank !== bRank) return aRank - bRank;
+		return availableModels.indexOf(a) - availableModels.indexOf(b);
+	})[0];
 }
 
 export interface ScopedModel {
@@ -92,6 +111,33 @@ export function formatModelString(model: Model<Api>): string {
 	return `${model.provider}/${model.id}`;
 }
 
+function getSingleRoutingOnly(routing: unknown): string | undefined {
+	if (!routing || typeof routing !== "object" || !("only" in routing) || !Array.isArray(routing.only)) {
+		return undefined;
+	}
+	if (routing.only.length !== 1) return undefined;
+	const upstream = routing.only[0];
+	return typeof upstream === "string" && upstream ? upstream : undefined;
+}
+
+function getSingleUpstreamRoute(model: Model<Api>): string | undefined {
+	const compat = model.compat;
+	if (!compat || typeof compat !== "object") return undefined;
+	if (modelMatchesHost(model, "vercelAIGateway") && "vercelGatewayRouting" in compat) {
+		return getSingleRoutingOnly(compat.vercelGatewayRouting);
+	}
+	if (modelMatchesHost(model, "openrouter") && "openRouterRouting" in compat) {
+		return getSingleRoutingOnly(compat.openRouterRouting);
+	}
+	return undefined;
+}
+
+export function formatModelStringWithRouting(model: Model<Api>): string {
+	const selector = formatModelString(model);
+	const upstream = getSingleUpstreamRoute(model);
+	return upstream ? `${selector}@${upstream}` : selector;
+}
+
 export function formatModelSelectorValue(selector: string, thinkingLevel: ThinkingLevel | undefined): string {
 	return thinkingLevel && thinkingLevel !== ThinkingLevel.Inherit ? `${selector}:${thinkingLevel}` : selector;
 }
@@ -161,7 +207,7 @@ const UPSTREAM_ROUTING_SLUG = /^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/i;
  * `@` or the suffix is not a bare provider slug, so model ids that legitimately
  * contain `@` (`claude-opus-4-8@default`, `workers-ai/@cf/...`) are never split.
  */
-function splitUpstreamRouting(pattern: string): { base: string; upstream: string } | undefined {
+export function splitUpstreamRouting(pattern: string): { base: string; upstream: string } | undefined {
 	const at = pattern.lastIndexOf("@");
 	if (at <= 0) return undefined;
 	const rest = pattern.slice(at + 1);
@@ -437,12 +483,10 @@ function matchModel(
 	context: ModelPreferenceContext,
 	options?: { modelRegistry?: CanonicalModelRegistry },
 ): Model<Api> | undefined {
-	// Explicit provider/model selectors always bypass canonical coalescing.
 	const exactRefMatch = findExactModelReferenceMatch(modelPattern, availableModels);
 	if (exactRefMatch) {
 		return exactRefMatch;
 	}
-
 	// Exact canonical ids coalesce provider variants before bare-id matching.
 	const exactCanonicalMatch = findExactCanonicalModelMatch(modelPattern, availableModels, options?.modelRegistry);
 	if (exactCanonicalMatch) {
@@ -481,6 +525,13 @@ function matchModel(
 			// The prefix is not a known provider in this candidate set, so treat the
 			// slash as part of the raw model ID and continue with generic matching.
 		} else {
+			// Let the routing fallback apply `@upstream` before fuzzy matching can consume the
+			// slug — but only for aggregator providers (OpenRouter / Vercel Gateway). Other
+			// providers have ids that legitimately end in `@` (Vertex `claude-opus-4-8@default`),
+			// and the fallback never routes them, so they must keep fuzzy matching.
+			if (splitUpstreamRouting(modelId) && providerModels.some(supportsUpstreamRouting)) {
+				return undefined;
+			}
 			const scored = providerModels
 				.map(model => ({ model, match: fuzzyMatch(modelId, model.id) }))
 				.filter(entry => entry.match.matches);

package/src/config/settings-schema.ts

@@ -3070,17 +3070,6 @@ export const SETTINGS_SCHEMA = {
 
 	// Optional tools
 
-	"renderMermaid.enabled": {
-		type: "boolean",
-		default: false,
-		ui: {
-			tab: "tools",
-			group: "Available Tools",
-			label: "Render Mermaid",
-			description: "Enable the render_mermaid tool for Mermaid-to-ASCII rendering",
-		},
-	},
-
 	"debug.enabled": {
 		type: "boolean",
 		default: true,