@oh-my-pi/pi-coding-agent 17.1.5 → 17.1.6

package/src/capability/index.ts

@@ -102,9 +102,10 @@ async function loadImpl<T>(
 	capability: Capability<T>,
 	providers: Provider<T>[],
 	ctx: LoadContext,
-	options: LoadOptions,
+	options: LoadOptions<T>,
 ): Promise<CapabilityResult<T>> {
 	const allItems: Array<T & { _source: SourceMeta; _shadowed?: boolean }> = [];
+	const suppressedItems = new Set<T & { _source: SourceMeta; _shadowed?: boolean }>();
 	const allWarnings: string[] = [];
 	const contributingProviders: string[] = [];
 	const disabledExtensionIds = options.includeDisabled
@@ -154,6 +155,21 @@ async function loadImpl<T>(
 				continue;
 			}
 
+			if (options.filter && !options.filter(itemWithSource)) {
+				continue;
+			}
+
+			if (options.suppress?.(itemWithSource)) {
+				// Suppressed items still claim their dedupe key below, so a
+				// suppressed higher-priority item shadows same-key lower-priority
+				// ones, but they never survive or equivalence-shadow survivors.
+				itemWithSource._source.providerName = provider.displayName;
+				const suppressed = itemWithSource as T & { _source: SourceMeta; _shadowed?: boolean };
+				suppressedItems.add(suppressed);
+				allItems.push(suppressed);
+				continue;
+			}
+
 			itemWithSource._source.providerName = provider.displayName;
 			allItems.push(itemWithSource as T & { _source: SourceMeta; _shadowed?: boolean });
 			contributedItemCount += 1;
@@ -164,21 +180,33 @@ async function loadImpl<T>(
 		}
 	}
 
-	// Deduplicate by key (first wins = highest priority)
-	const seen = new Map<string, number>();
+	// Deduplicate by key or semantic equivalence (first wins = highest priority)
+	const seen = new Set<string>();
 	const deduped: Array<T & { _source: SourceMeta }> = [];
+	const equivalent = capability.equivalent;
 
-	for (let i = 0; i < allItems.length; i++) {
-		const item = allItems[i];
+	for (const item of allItems) {
 		const key = capability.key(item);
 
+		if (suppressedItems.has(item)) {
+			// Claim key ownership (same-name precedence, including disabled
+			// state) without surviving or equivalence-shadowing survivors.
+			if (key !== undefined) seen.add(key);
+			continue;
+		}
+
 		if (key === undefined) {
 			deduped.push(item);
-		} else if (!seen.has(key)) {
-			seen.set(key, i);
-			deduped.push(item);
-		} else {
+			continue;
+		}
+
+		const keySeen = seen.has(key);
+		seen.add(key);
+		const aliasSeen = !keySeen && equivalent !== undefined && deduped.some(existing => equivalent(existing, item));
+		if (keySeen || aliasSeen) {
 			item._shadowed = true;
+		} else {
+			deduped.push(item);
 		}
 	}
 
@@ -198,7 +226,7 @@ async function loadImpl<T>(
 
 	return {
 		items: deduped,
-		all: allItems,
+		all: suppressedItems.size > 0 ? allItems.filter(item => !suppressedItems.has(item)) : allItems,
 		warnings: allWarnings,
 		providers: contributingProviders,
 	};
@@ -207,7 +235,7 @@ async function loadImpl<T>(
 /**
  * Filter providers based on options and disabled state.
  */
-function filterProviders<T>(capability: Capability<T>, options: LoadOptions): Provider<T>[] {
+function filterProviders<T>(capability: Capability<T>, options: LoadOptions<T>): Provider<T>[] {
 	let providers = (capability.providers as Provider<T>[]).filter(p => !disabledProviders.has(p.id));
 
 	if (options.providers) {
@@ -225,7 +253,10 @@ function filterProviders<T>(capability: Capability<T>, options: LoadOptions): Pr
 /**
  * Load a capability by ID.
  */
-export async function loadCapability<T>(capabilityId: string, options: LoadOptions = {}): Promise<CapabilityResult<T>> {
+export async function loadCapability<T>(
+	capabilityId: string,
+	options: LoadOptions<T> = {},
+): Promise<CapabilityResult<T>> {
 	const capability = capabilities.get(capabilityId) as Capability<T> | undefined;
 	if (!capability) {
 		throw new Error(`Unknown capability: "${capabilityId}"`);

package/src/capability/mcp.ts

@@ -53,11 +53,32 @@ export interface MCPServer {
 	_source: SourceMeta;
 }
 
+/** Compare the transport inputs that determine which MCP endpoint gets connected. */
+function isSameMCPConnection(left: MCPServer, right: MCPServer): boolean {
+	if (!Bun.deepEquals(left.auth, right.auth) || !Bun.deepEquals(left.oauth, right.oauth)) return false;
+
+	const leftTransport = left.transport ?? (left.command ? "stdio" : left.url ? "http" : "stdio");
+	const rightTransport = right.transport ?? (right.command ? "stdio" : right.url ? "http" : "stdio");
+	if (leftTransport !== rightTransport) return false;
+
+	if (leftTransport === "stdio") {
+		return (
+			left.command === right.command &&
+			Bun.deepEquals(left.args, right.args) &&
+			Bun.deepEquals(left.env, right.env) &&
+			left.cwd === right.cwd
+		);
+	}
+
+	return left.url === right.url && Bun.deepEquals(left.headers, right.headers);
+}
+
 export const mcpCapability = defineCapability<MCPServer>({
 	id: "mcps",
 	displayName: "MCP Servers",
 	description: "Model Context Protocol server configurations for external tool integrations",
 	key: server => server.name,
+	equivalent: isSameMCPConnection,
 	toExtensionId: server => `mcp:${server.name}`,
 	validate: server => {
 		if (!server.name) return "Missing server name";

package/src/capability/types.ts

@@ -59,7 +59,7 @@ export interface Provider<T> {
 /**
  * Options for loading a capability.
  */
-export interface LoadOptions {
+export interface LoadOptions<T = unknown> {
 	/** Only use these providers (by ID). Default: all registered */
 	providers?: string[];
 	/** Exclude these providers (by ID). Default: none */
@@ -72,6 +72,22 @@ export interface LoadOptions {
 	includeDisabled?: boolean;
 	/** Explicit disabled extension IDs to apply instead of settings. */
 	disabledExtensions?: string[];
+	/**
+	 * Drop items before deduplication as if they never existed (e.g. scope
+	 * exclusions). A dropped item neither survives nor claims its dedupe key,
+	 * so it cannot shadow anything. Receives the item with its attached
+	 * `_source`.
+	 */
+	filter?(item: T & { _source: SourceMeta }): boolean;
+	/**
+	 * Exclude items from the results while letting them claim their dedupe key.
+	 * A suppressed higher-priority item still shadows same-key lower-priority
+	 * items (a disabled project server keeps the same-named user server off),
+	 * but never equivalence-shadows a differently-keyed survivor — so a
+	 * suppressed alias cannot starve an enabled equivalent connection.
+	 * Return `true` to suppress. Receives the item with its attached `_source`.
+	 */
+	suppress?(item: T & { _source: SourceMeta }): boolean;
 }
 
 /**
@@ -122,6 +138,9 @@ export interface Capability<T> {
 	 */
 	key(item: T): string | undefined;
 
+	/** Treat items with different keys as aliases; the first equivalent item wins. */
+	equivalent?(left: T, right: T): boolean;
+
 	/**
 	 * Optional validation. Return error message if invalid, undefined if valid.
 	 */

package/src/cli/read-cli.ts

@@ -8,6 +8,12 @@
 import { getProjectDir } from "@oh-my-pi/pi-utils";
 import chalk from "chalk";
 import { Settings } from "../config/settings";
+import { extractUriScheme } from "../internal-urls/parse";
+import { InternalUrlRouter } from "../internal-urls/router";
+import { discoverAndLoadMCPTools } from "../mcp/loader";
+import { MCPManager } from "../mcp/manager";
+import { discoverAuthStorage } from "../session/auth-broker-config";
+import type { AuthStorage } from "../session/auth-storage";
 import type { ToolSession } from "../tools";
 import { wrapToolWithMetaNotice } from "../tools/output-meta";
 import { ReadTool } from "../tools/read";
@@ -17,6 +23,17 @@ export interface ReadCommandArgs {
 	path: string;
 }
 
+function shouldDiscoverMcp(path: string): boolean {
+	// MCP resource URIs may be hierarchical (`test://notes`) or opaque
+	// (`urn:example:document`); `extractUriScheme` recognizes both while
+	// rejecting Windows drive paths and selector-shaped filesystem inputs.
+	const scheme = extractUriScheme(path);
+	if (!scheme) return false;
+	if (scheme === "mcp") return true;
+	if (["conflict", "file", "http", "https"].includes(scheme)) return false;
+	return InternalUrlRouter.instance().getHandler(scheme) === undefined;
+}
+
 export async function runReadCommand(cmd: ReadCommandArgs): Promise<void> {
 	if (!cmd.path) {
 		process.stderr.write(chalk.red("error: path is required\n"));
@@ -34,9 +51,26 @@ export async function runReadCommand(cmd: ReadCommandArgs): Promise<void> {
 		getSessionSpawns: () => "*",
 	};
 
-	const tool = wrapToolWithMetaNotice(new ReadTool(session));
+	let authStorage: AuthStorage | undefined;
+	let mcpManager: MCPManager | undefined;
+	let failed = false;
 
 	try {
+		if (shouldDiscoverMcp(cmd.path)) {
+			authStorage = await discoverAuthStorage();
+			const result = await discoverAndLoadMCPTools(cwd, {
+				enableProjectConfig: settings.get("mcp.enableProjectConfig") ?? true,
+				filterExa: true,
+				filterBrowser: settings.get("browser.enabled") ?? false,
+				cacheStorage: settings.getStorage(),
+				authStorage,
+			});
+			mcpManager = result.manager;
+			session.mcpManager = mcpManager;
+			MCPManager.setInstance(mcpManager);
+		}
+
+		const tool = wrapToolWithMetaNotice(new ReadTool(session));
 		const result = await tool.execute("omp-read", { path: cmd.path });
 
 		for (const block of result.content) {
@@ -52,6 +86,14 @@ export async function runReadCommand(cmd: ReadCommandArgs): Promise<void> {
 		}
 	} catch (err) {
 		process.stderr.write(`${chalk.red(renderError(err))}\n`);
-		process.exit(1);
+		failed = true;
+	} finally {
+		if (mcpManager) {
+			await mcpManager.disconnectAll();
+			if (MCPManager.instance() === mcpManager) MCPManager.setInstance(undefined);
+		}
+		authStorage?.close();
 	}
+
+	if (failed) process.exit(1);
 }

package/src/config/settings-schema.ts

@@ -935,7 +935,7 @@ export const SETTINGS_SCHEMA = {
 			group: "Display",
 			label: "Terminal Title Run State",
 			description:
-				"Show the agent run state in the terminal title's separator — an animated spinner while working, '>' when it's your turn, '!' when the agent is waiting on you",
+				"Show the agent run state in the terminal title's separator — an animated spinner while working (a static ':' on Windows), '>' when it's your turn, '!' when the agent is waiting on you",
 		},
 	},
 
@@ -4476,6 +4476,18 @@ export const SETTINGS_SCHEMA = {
 		},
 	},
 
+	"task.enableEffort": {
+		type: "boolean",
+		default: false,
+		ui: {
+			tab: "tasks",
+			group: "Subagents",
+			label: "Per-Task Effort",
+			description:
+				"Expose the optional effort parameter on task spawns, allowing callers to override each subagent's thinking level",
+		},
+	},
+
 	"task.maxConcurrency": {
 		type: "number",
 		default: 32,
@@ -4588,6 +4600,20 @@ export const SETTINGS_SCHEMA = {
 		},
 	},
 
+	"task.maxEffort": {
+		type: "enum",
+		values: THINKING_EFFORTS,
+		default: "max",
+		ui: {
+			tab: "tasks",
+			group: "Subagents",
+			label: "Maximum Per-Spawn Effort",
+			description:
+				"Maximum reasoning effort allowed for the task tool's per-spawn effort hint. Lower values prevent callers from escalating subagents above this ceiling; the default preserves the model's full range.",
+			options: THINKING_EFFORTS.map(getThinkingLevelMetadata),
+		},
+	},
+
 	"task.disabledAgents": {
 		type: "array",
 		default: [] as string[],

package/src/eval/py/runner.py

@@ -1057,7 +1057,7 @@ async def _run_compiled_async(code, ns: dict, *, want_value: bool) -> Any:
 
 
 def _compile_source(source: str) -> tuple[Any, Any | None, bool]:
-    module = ast.parse(source, mode="exec")
+    module = ast.parse(source, "<cell>", "exec")
     if not module.body:
         return None, None, False
 
@@ -1279,7 +1279,21 @@ async def _handle_request_async(req: dict) -> None:
 
 
 def _emit_error(rid: str, exc: BaseException) -> None:
-    tb_lines = traceback.format_exception(type(exc), exc, exc.__traceback__)
+    if isinstance(exc, SyntaxError) and exc.filename == "<cell>":
+        # Syntax error in the cell source itself: every stack frame is runner
+        # machinery, so emit only the caret display, like a REPL.
+        tb_lines = traceback.format_exception_only(type(exc), exc)
+    else:
+        # Drop the leading runner-internal frames (_handle_request_async ->
+        # _exec_source_async -> _run_compiled_*) so tracebacks start at user
+        # code. If the exception never reached user code it is a runner bug;
+        # keep the full traceback because those frames are the diagnosis.
+        tb = exc.__traceback__
+        while tb is not None and tb.tb_frame.f_code.co_filename == __file__:
+            tb = tb.tb_next
+        tb_lines = traceback.format_exception(
+            type(exc), exc, tb if tb is not None else exc.__traceback__
+        )
     _emit(
         {
             "type": "error",

package/src/extensibility/extensions/runner.ts

@@ -37,6 +37,7 @@ import type {
 	ExtensionRuntime,
 	ExtensionShortcut,
 	ExtensionUIContext,
+	ExtensionUIDialogOptions,
 	InputEvent,
 	InputEventResult,
 	MessageRenderer,
@@ -105,6 +106,66 @@ function handlerTimeoutForEvent(eventType: string): number {
 const EXTENSION_HANDLER_TIMEOUT = Symbol("extensionHandlerTimeout");
 const EXTENSION_HANDLER_ABORTED = Symbol("extensionHandlerAborted");
 
+function attachHandlerSignal(
+	dialogOptions: ExtensionUIDialogOptions | undefined,
+	handlerSignal: AbortSignal,
+): ExtensionUIDialogOptions {
+	if (!dialogOptions) return { signal: handlerSignal };
+	if (!dialogOptions.signal) return { ...dialogOptions, signal: handlerSignal };
+	if (dialogOptions.signal === handlerSignal) return dialogOptions;
+	return { ...dialogOptions, signal: AbortSignal.any([dialogOptions.signal, handlerSignal]) };
+}
+
+function createHandlerUIContext(ui: ExtensionUIContext, handlerSignal: AbortSignal): ExtensionUIContext {
+	const askDialog = ui.askDialog;
+	const dialogMethods = {
+		select: (title, options, dialogOptions) =>
+			ui.select(title, options, attachHandlerSignal(dialogOptions, handlerSignal)),
+		confirm: (title, message, dialogOptions) =>
+			ui.confirm(title, message, attachHandlerSignal(dialogOptions, handlerSignal)),
+		input: (title, placeholder, dialogOptions) =>
+			ui.input(title, placeholder, attachHandlerSignal(dialogOptions, handlerSignal)),
+		askDialog: askDialog
+			? (questions, dialogOptions) =>
+					askDialog.call(ui, questions, attachHandlerSignal(dialogOptions, handlerSignal))
+			: undefined,
+		editor: (title, prefill, dialogOptions, editorOptions) =>
+			ui.editor(title, prefill, attachHandlerSignal(dialogOptions, handlerSignal), editorOptions),
+	} satisfies Pick<ExtensionUIContext, "select" | "confirm" | "input" | "askDialog" | "editor">;
+	const delegatedMethods = new Map<PropertyKey, unknown>();
+
+	return new Proxy(ui, {
+		get(target, property) {
+			if (Object.hasOwn(dialogMethods, property)) {
+				return Reflect.get(dialogMethods, property, dialogMethods);
+			}
+			const cached = delegatedMethods.get(property);
+			if (cached) return cached;
+			const value: unknown = Reflect.get(target, property, target);
+			if (typeof value !== "function") return value;
+			const delegated: unknown = value.bind(target);
+			delegatedMethods.set(property, delegated);
+			return delegated;
+		},
+	});
+}
+
+/**
+ * Scope `ctx` to a single handler run without spreading it: `{ ...ctx }` would
+ * snapshot live accessors (notably the `model` getter), so a handler calling
+ * `pi.setModel()` and then reading `ctx.model` would see a stale model.
+ * Prototype delegation keeps every getter live while overriding `ui`.
+ */
+function createHandlerContext(ctx: ExtensionContext, handlerSignal: AbortSignal): ExtensionContext {
+	const scoped: ExtensionContext = Object.create(ctx);
+	Object.defineProperty(scoped, "ui", {
+		value: createHandlerUIContext(ctx.ui, handlerSignal),
+		enumerable: true,
+		configurable: true,
+	});
+	return scoped;
+}
+
 /**
  * Race `work` against a `timeoutMs` budget and optional cancellation signal,
  * clearing the timer and abort listener as soon as one branch settles.
@@ -118,19 +179,37 @@ const EXTENSION_HANDLER_ABORTED = Symbol("extensionHandlerAborted");
  * can `clearTimeout` on the winning branch.
  */
 async function raceHandlerWithTimeout<T>(
-	work: Promise<T>,
+	work: (handlerSignal: AbortSignal) => Promise<T> | T,
 	timeoutMs: number,
 	signal?: AbortSignal,
 ): Promise<T | typeof EXTENSION_HANDLER_TIMEOUT | typeof EXTENSION_HANDLER_ABORTED> {
 	if (signal?.aborted) return EXTENSION_HANDLER_ABORTED;
+
+	const timeoutController = new AbortController();
+	const handlerSignal = signal ? AbortSignal.any([signal, timeoutController.signal]) : timeoutController.signal;
 	const { promise: interruptPromise, resolve: resolveInterrupt } = Promise.withResolvers<
 		typeof EXTENSION_HANDLER_TIMEOUT | typeof EXTENSION_HANDLER_ABORTED
 	>();
-	const timer = setTimeout(() => resolveInterrupt(EXTENSION_HANDLER_TIMEOUT), timeoutMs);
 	const onAbort = () => resolveInterrupt(EXTENSION_HANDLER_ABORTED);
 	signal?.addEventListener("abort", onAbort, { once: true });
+	const timer = setTimeout(() => {
+		timeoutController.abort(new DOMException(`Handler timed out after ${timeoutMs}ms`, "TimeoutError"));
+		resolveInterrupt(EXTENSION_HANDLER_TIMEOUT);
+	}, timeoutMs);
 	try {
-		return await Promise.race([work, interruptPromise]);
+		if (signal?.aborted) return EXTENSION_HANDLER_ABORTED;
+		const workPromise = Promise.resolve(work(handlerSignal));
+		const result = await Promise.race([workPromise, interruptPromise]);
+		if (result === EXTENSION_HANDLER_TIMEOUT) {
+			await Promise.race([
+				workPromise.then(
+					() => undefined,
+					() => undefined,
+				),
+				Bun.sleep(0),
+			]);
+		}
+		return result;
 	} finally {
 		clearTimeout(timer);
 		signal?.removeEventListener("abort", onAbort);
@@ -637,7 +716,11 @@ export class ExtensionRunner {
 				: undefined;
 		if (signal?.aborted) return undefined;
 		try {
-			const handlerResult = await raceHandlerWithTimeout(Promise.resolve(handler(event, ctx)), timeoutMs, signal);
+			const handlerResult = await raceHandlerWithTimeout(
+				handlerSignal => handler(event, createHandlerContext(ctx, handlerSignal)),
+				timeoutMs,
+				signal,
+			);
 			if (handlerResult === EXTENSION_HANDLER_ABORTED) return undefined;
 			if (handlerResult === EXTENSION_HANDLER_TIMEOUT) {
 				const error = `handler timed out after ${timeoutMs}ms`;
@@ -799,7 +882,10 @@ export class ExtensionRunner {
 
 			for (const handler of handlers) {
 				try {
-					const handlerResult = await raceHandlerWithTimeout(Promise.resolve(handler(event, ctx)), timeoutMs);
+					const handlerResult = await raceHandlerWithTimeout(
+						handlerSignal => handler(event, createHandlerContext(ctx, handlerSignal)),
+						timeoutMs,
+					);
 
 					if (handlerResult === EXTENSION_HANDLER_TIMEOUT) {
 						const error = `handler timed out after ${timeoutMs}ms`;

package/src/extensibility/extensions/types.ts

@@ -1044,7 +1044,6 @@ export interface RegisteredCommand {
 // ============================================================================
 
 /** Handler function type for events */
-// biome-ignore lint/suspicious/noConfusingVoidType: void allows bare return statements
 export type ExtensionHandler<E, R = undefined> = (event: E, ctx: ExtensionContext) => Promise<R | void> | R | void;
 
 /** Service tiers accepted by each provider family. */

package/src/extensibility/hooks/types.ts

@@ -444,7 +444,6 @@ export type {
  * Handler function type for each event.
  * Handlers can return R, undefined, or void (bare return statements).
  */
-// biome-ignore lint/suspicious/noConfusingVoidType: void allows bare return statements in handlers
 export type HookHandler<E, R = undefined> = (event: E, ctx: HookContext) => Promise<R | void> | R | void;
 
 export interface HookMessageRenderOptions {

package/src/internal-urls/mcp-protocol.ts

@@ -21,6 +21,15 @@ function getUriTemplateMatchScore(
 }
 
 function extractResourceUri(url: InternalUrl): string {
+	const scheme = url.protocol.replace(/:$/, "").toLowerCase();
+	if (scheme !== "mcp") {
+		// Server-advertised native URI (hierarchical or opaque). Preserve the
+		// input byte-for-byte: `resolveTargetServer` matches by exact string
+		// equality, so e.g. `catalog://root/` must keep its trailing slash.
+		return url.rawHref ?? url.href;
+	}
+	// Legacy `mcp://<resource-uri>` wrapper: reconstruct the wrapped URI and
+	// elide a bare trailing `/` that URL parsing adds to host-only forms.
 	const host = url.rawHost || url.hostname;
 	const rawPathname = url.rawPathname ?? url.pathname;
 	const hasPath = rawPathname && rawPathname !== "/";
@@ -95,10 +104,11 @@ function formatAvailableResources(mcpManager: MCPManager): string {
 }
 
 /**
- * Protocol handler for mcp:// URLs.
+ * Protocol handler for MCP resources.
  *
- * URL form:
+ * URL forms:
  * - mcp://<resource-uri> (e.g. mcp://test://notes, mcp://ibkr://portfolio/positions)
+ * - A resource's native URI when its scheme has no OMP handler (e.g. ags://capabilities/current-host)
  */
 export class McpProtocolHandler implements ProtocolHandler {
 	readonly scheme = "mcp";
@@ -111,7 +121,11 @@ export class McpProtocolHandler implements ProtocolHandler {
 		}
 
 		const uri = extractResourceUri(url);
-		const targetServer = resolveTargetServer(mcpManager, uri);
+		let targetServer = resolveTargetServer(mcpManager, uri);
+		if (!targetServer) {
+			await Promise.allSettled(mcpManager.getConnectedServers().map(name => mcpManager.ensureServerResources(name)));
+			targetServer = resolveTargetServer(mcpManager, uri);
+		}
 		if (!targetServer) {
 			throw new Error(
 				`No MCP server has resource "${uri}".\n\nAvailable resources:\n${formatAvailableResources(mcpManager)}`,

package/src/internal-urls/parse.ts

@@ -13,6 +13,36 @@ import type { InternalUrl } from "./types";
 
 const SCHEME_HOST_RE = /^([a-z][a-z0-9+.-]*):\/\/([^/?#]*)/i;
 const PATHNAME_RE = /^[a-z][a-z0-9+.-]*:\/\/[^/?#]*(\/[^?#]*)?/i;
+// Opaque URI form (`urn:example:document`, `custom:item`) — an RFC 3986 scheme
+// followed by `:` without `//`. Guarded separately in `extractUriScheme`.
+const OPAQUE_URI_RE = /^([a-z][a-z0-9+.-]*):(.+)$/is;
+// A read-tool selector chain (`12`, `1-20,30+5`, `raw`, `raw:2-4`, `conflicts`)
+// so `Makefile:12` or `notes:raw` is not mistaken for an opaque URI.
+const SELECTOR_CHUNK_SRC = String.raw`(?:raw|conflicts|-?\d+(?:[-+]\d+)?(?:,\d+(?:[-+]\d+)?)*)`;
+const SELECTOR_CHAIN_RE = new RegExp(`^${SELECTOR_CHUNK_SRC}(?::${SELECTOR_CHUNK_SRC})*$`, "i");
+
+/**
+ * Extract the lowercased scheme from a URI-shaped input, or `undefined` when
+ * the input does not look like a URI.
+ *
+ * Accepts both hierarchical (`scheme://…`) and opaque (`scheme:rest`) forms —
+ * MCP resource URIs may be opaque (`urn:example:document`, `custom:item`).
+ * The opaque form is guarded against path-like false positives:
+ * - Windows drive paths (`C:\…`, `C:/…`, `C:foo`) — single-letter scheme.
+ * - Filenames with extensions (`foo.ts:50`) — dot in the scheme segment.
+ * - Read-tool selector tails (`Makefile:12`, `README:raw:1-20`).
+ */
+export function extractUriScheme(input: string): string | undefined {
+	const hierarchical = input.match(SCHEME_HOST_RE);
+	if (hierarchical) return hierarchical[1].toLowerCase();
+	const opaque = input.match(OPAQUE_URI_RE);
+	if (!opaque) return undefined;
+	const [, scheme, rest] = opaque;
+	if (scheme.length === 1) return undefined;
+	if (scheme.includes(".")) return undefined;
+	if (SELECTOR_CHAIN_RE.test(rest)) return undefined;
+	return scheme.toLowerCase();
+}
 
 /**
  * Parse an internal URL into an InternalUrl.
@@ -68,5 +98,6 @@ export function parseInternalUrl(input: string): InternalUrl {
 	const result = parsed as InternalUrl;
 	result.rawHost = rawHost;
 	result.rawPathname = pathMatch?.[1] ?? parsed.pathname;
+	result.rawHref = input;
 	return result;
 }

package/src/internal-urls/router.ts

@@ -13,7 +13,7 @@ import { LocalProtocolHandler } from "./local-protocol";
 import { McpProtocolHandler } from "./mcp-protocol";
 import { MemoryProtocolHandler } from "./memory-protocol";
 import { OmpProtocolHandler } from "./omp-protocol";
-import { parseInternalUrl } from "./parse";
+import { extractUriScheme, parseInternalUrl } from "./parse";
 import { RuleProtocolHandler } from "./rule-protocol";
 import { SkillProtocolHandler } from "./skill-protocol";
 import { SshProtocolHandler } from "./ssh-protocol";
@@ -79,6 +79,20 @@ export class InternalUrlRouter {
 		return this.#handlers.has(match[1].toLowerCase());
 	}
 
+	/**
+	 * Whether read can resolve this URL through either a native handler or the
+	 * MCP resource fallback. MCP resources may use arbitrary custom schemes and
+	 * may be opaque (`urn:example:document`) rather than hierarchical.
+	 */
+	canResolve(input: string): boolean {
+		const scheme = extractUriScheme(input);
+		if (!scheme) return false;
+		// Registered handlers only accept the hierarchical `scheme://` form;
+		// opaque inputs reach the MCP resource fallback alone.
+		if (this.#handlers.has(scheme)) return this.canHandle(input);
+		return this.#isMcpResourceScheme(scheme);
+	}
+
 	/** Schemes whose handler supports host/path autocomplete. */
 	completionSchemes(): string[] {
 		const schemes: string[] = [];
@@ -98,10 +112,16 @@ export class InternalUrlRouter {
 		return handler.complete(query, context);
 	}
 
-	#route(input: string): { parsed: InternalUrl; handler: ProtocolHandler } {
+	#isMcpResourceScheme(scheme: string): boolean {
+		return !["file", "http", "https"].includes(scheme) && this.#handlers.has("mcp");
+	}
+
+	#route(input: string, allowMcpResource = false): { parsed: InternalUrl; handler: ProtocolHandler } {
 		const parsed = parseInternalUrl(input);
 		const scheme = parsed.protocol.replace(/:$/, "").toLowerCase();
-		const handler = this.#handlers.get(scheme);
+		const handler =
+			this.#handlers.get(scheme) ??
+			(allowMcpResource && this.#isMcpResourceScheme(scheme) ? this.#handlers.get("mcp") : undefined);
 		if (!handler) {
 			const available = Array.from(this.#handlers.keys())
 				.map(candidate => `${candidate}://`)
@@ -113,7 +133,7 @@ export class InternalUrlRouter {
 
 	/** Resolve an internal URL through its registered protocol handler. */
 	async resolve(input: string, context?: ResolveContext): Promise<InternalResource> {
-		const { parsed, handler } = this.#route(input);
+		const { parsed, handler } = this.#route(input, true);
 		const resource = await handler.resolve(parsed, context);
 		return { ...resource, immutable: resource.immutable ?? handler.immutable };
 	}

package/src/internal-urls/types.ts

@@ -70,6 +70,12 @@ export interface InternalUrl extends URL {
 	 * Raw pathname extracted from input, preserving traversal markers before URL normalization.
 	 */
 	rawPathname?: string;
+	/**
+	 * Exact input string this URL was parsed from, before any normalization.
+	 * Set by `parseInternalUrl`; used where byte-exact URI matching matters
+	 * (e.g. MCP resource URIs compared by string equality).
+	 */
+	rawHref?: string;
 }
 
 /**

package/src/live/transport.ts

@@ -1,5 +1,5 @@
 import { type AuthStorage, isAuthRetryableError, type OAuthAccess, withOAuthAccess } from "@oh-my-pi/pi-ai";
-import { getProxyForProvider, wrapFetchForProxy } from "@oh-my-pi/pi-ai/utils/proxy";
+import { getProxyForUrl, wrapFetchForProxy } from "@oh-my-pi/pi-ai/utils/proxy";
 import {
 	CODEX_BASE_URL,
 	CODEX_CLIENT_VERSION,
@@ -252,7 +252,7 @@ export class CodexLiveTransport {
 		const url = buildLiveSidebandUrl(callId);
 		const options = {
 			headers: liveSessionHeaders(access, this.#options.sessionId, this.#realtimeSessionId, attestation),
-			proxy: getProxyForProvider(LIVE_PROVIDER),
+			proxy: getProxyForUrl(LIVE_PROVIDER, new URL(url)),
 		} satisfies Bun.WebSocketOptions;
 		const socket: Bun.WebSocket = Reflect.construct(WebSocket, [url, options]);
 		socket.binaryType = "nodebuffer";