@narumitw/pi-chrome-devtools 0.52.1 → 0.52.3

package/src/chrome-devtools.ts

@@ -2,9 +2,11 @@ import type { ExtensionAPI, ExtensionCommandContext } from "@earendil-works/pi-c
 import { shutdownManagedBrowser } from "./browser-manager.js";
 import {
 	availableChromeDevtoolsTools,
-	configureLazyChromeDevtoolsTools,
+	configureChromeDevtoolsToolExposure,
 	createChromeDevtoolsLoadTool,
 	initializeAvailableChromeDevtoolsTools,
+	requireEagerChromeDevtoolsToolExposure,
+	supportsNativeDeferredToolLoading,
 } from "./lazy-tools.js";
 import { applyRuntimeBrowserSettings, state } from "./runtime.js";
 import { loadSettings, waitForSettingsWrites } from "./settings.js";
@@ -41,7 +43,7 @@ const COMMAND_COMPLETIONS = [
 	{ value: "quickstart", label: "quickstart", description: "Show endpoint and launch help" },
 	{ value: "status", label: "status", description: "Show tool and settings status" },
 	{ value: "settings", label: "settings", description: "Edit browser connection settings" },
-	{ value: "tools", label: "tools", description: "Choose lazy-loadable Chrome DevTools tools" },
+	{ value: "tools", label: "tools", description: "Choose available Chrome DevTools tools" },
 	{ value: "toggle", label: "toggle", description: "Alias for tools" },
 	{ value: "select", label: "select", description: "Compatibility alias for tools" },
 	{ value: "enable", label: "enable", description: "Make all Chrome DevTools tools available" },
@@ -90,7 +92,13 @@ export default function chromeDevtools(pi: ExtensionAPI) {
 			settings.kind === "loaded" && settings.settings.tools
 				? settings.settings.tools
 				: availableChromeDevtoolsTools(pi);
-		configureLazyChromeDevtoolsTools(pi, availableTools);
+		configureChromeDevtoolsToolExposure(pi, availableTools, ctx.model);
+	});
+
+	pi.on("model_select", (event) => {
+		if (!supportsNativeDeferredToolLoading(event.model)) {
+			requireEagerChromeDevtoolsToolExposure(pi);
+		}
 	});
 
 	pi.on("session_shutdown", async (_event, ctx) => {

package/src/lazy-tools.ts

@@ -1,4 +1,8 @@
-import { defineTool, type ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import {
+	defineTool,
+	type ExtensionAPI,
+	type ExtensionContext,
+} from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
 import { CHROME_DEVTOOLS_TOOL_NAMES, type ChromeDevToolsToolName } from "./tool-names.js";
 
@@ -13,6 +17,7 @@ const existingAvailableToolsStore = sharedGlobal[AVAILABLE_TOOLS_STORE];
 const availableToolsByApi =
 	existingAvailableToolsStore ?? new WeakMap<ExtensionAPI, Set<ChromeDevToolsToolName>>();
 if (!existingAvailableToolsStore) sharedGlobal[AVAILABLE_TOOLS_STORE] = availableToolsByApi;
+const lazyExposureByApi = new WeakMap<ExtensionAPI, boolean>();
 
 const SEARCH_TEXT: Record<ChromeDevToolsToolName, string> = {
 	chrome_devtools_list_pages: "list open inspectable chrome browser pages tabs targets",
@@ -31,15 +36,30 @@ export function initializeAvailableChromeDevtoolsTools(pi: ExtensionAPI) {
 	);
 }
 
-export function configureLazyChromeDevtoolsTools(
+export function configureChromeDevtoolsToolExposure(
 	pi: ExtensionAPI,
 	availableTools: readonly ChromeDevToolsToolName[],
+	model?: ExtensionContext["model"],
 ) {
-	setAvailableTools(pi, availableTools);
+	const available = setAvailableTools(pi, availableTools);
+	const lazyExposure = supportsNativeDeferredToolLoading(model);
+	lazyExposureByApi.set(pi, lazyExposure);
+	const exposedTools = lazyExposure
+		? []
+		: CHROME_DEVTOOLS_TOOL_NAMES.filter((name) => available.has(name));
 	const nonCapabilityTools = pi
 		.getActiveTools()
 		.filter((name) => !CHROME_DEVTOOLS_TOOL_NAMES.includes(name as ChromeDevToolsToolName));
-	pi.setActiveTools(unique([...nonCapabilityTools, CHROME_DEVTOOLS_LOAD_TOOL_NAME]));
+	pi.setActiveTools(
+		unique([...nonCapabilityTools, CHROME_DEVTOOLS_LOAD_TOOL_NAME, ...exposedTools]),
+	);
+}
+
+export function requireEagerChromeDevtoolsToolExposure(pi: ExtensionAPI) {
+	lazyExposureByApi.set(pi, false);
+	const active = pi.getActiveTools();
+	const available = availableChromeDevtoolsTools(pi);
+	pi.setActiveTools(unique([...active, CHROME_DEVTOOLS_LOAD_TOOL_NAME, ...available]));
 }
 
 export function applyAvailableChromeDevtoolsTools(
@@ -47,14 +67,46 @@ export function applyAvailableChromeDevtoolsTools(
 	availableTools: readonly ChromeDevToolsToolName[],
 ) {
 	const available = setAvailableTools(pi, availableTools);
+	const lazyExposure = lazyExposureByApi.get(pi) === true;
 	const active = pi
 		.getActiveTools()
 		.filter(
 			(name) =>
 				!CHROME_DEVTOOLS_TOOL_NAMES.includes(name as ChromeDevToolsToolName) ||
-				available.has(name as ChromeDevToolsToolName),
+				(lazyExposure && available.has(name as ChromeDevToolsToolName)),
 		);
-	pi.setActiveTools(unique([...active, CHROME_DEVTOOLS_LOAD_TOOL_NAME]));
+	const eagerTools = lazyExposure
+		? []
+		: CHROME_DEVTOOLS_TOOL_NAMES.filter((name) => available.has(name));
+	pi.setActiveTools(unique([...active, CHROME_DEVTOOLS_LOAD_TOOL_NAME, ...eagerTools]));
+}
+
+export function chromeDevtoolsToolExposureMode(pi: ExtensionAPI) {
+	return lazyExposureByApi.get(pi) === true ? "native deferred" : "eager";
+}
+
+export function supportsNativeDeferredToolLoading(model: ExtensionContext["model"]): boolean {
+	if (!model) return false;
+	if (model.api === "anthropic-messages") {
+		const configured = compatBoolean(model.compat, "supportsToolReferences");
+		if (configured !== undefined) return configured;
+		if (model.provider !== "anthropic" || model.id.includes("haiku")) return false;
+		const version = model.id.match(/^claude-(?:opus|sonnet|fable)-(\d+)(?:-(\d+))?(?:-|$)/);
+		if (!version) return false;
+		const major = Number(version[1]);
+		const minor = version[2] && version[2].length < 8 ? Number(version[2]) : 0;
+		return major > 4 || (major === 4 && minor >= 5);
+	}
+	if (model.api === "openai-completions") {
+		return compatString(model.compat, "deferredToolsMode") === "kimi";
+	}
+	if (model.api === "openai-responses" || model.api === "openai-codex-responses") {
+		return (
+			compatBoolean(model.compat, "supportsAdditionalTools") === true ||
+			compatBoolean(model.compat, "supportsToolSearch") === true
+		);
+	}
+	return false;
 }
 
 export function availableChromeDevtoolsTools(pi: ExtensionAPI) {
@@ -138,6 +190,18 @@ function setAvailableTools(pi: ExtensionAPI, availableTools: readonly ChromeDevT
 	return available;
 }
 
+function compatBoolean(value: unknown, key: string) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return undefined;
+	const record = value as Record<string, unknown>;
+	return typeof record[key] === "boolean" ? record[key] : undefined;
+}
+
+function compatString(value: unknown, key: string) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return undefined;
+	const record = value as Record<string, unknown>;
+	return typeof record[key] === "string" ? record[key] : undefined;
+}
+
 function unique(values: readonly string[]) {
 	return [...new Set(values)];
 }

package/src/menu.ts

@@ -306,7 +306,7 @@ export async function showChromeDevtoolsToolWorkflow(
 				current.draft = new Set(selectedTools);
 				current.applied = true;
 				ctx.ui.notify(
-					`Saved: ${selectedTools.length} of ${CHROME_DEVTOOLS_TOOL_NAMES.length} browser tools available to lazy-load.`,
+					`Saved: ${selectedTools.length} of ${CHROME_DEVTOOLS_TOOL_NAMES.length} browser tools available.`,
 					"info",
 				);
 				return { kind: "close" };
@@ -378,7 +378,7 @@ function buildMenuSnapshot(pi: ExtensionAPI, settings: SettingsLoadResult): Menu
 
 function mainStateLines(snapshot: MenuSnapshot) {
 	return sanitizeLines([
-		`Lazy catalog: ${snapshot.activeTools.length} of ${CHROME_DEVTOOLS_TOOL_NAMES.length} available · ${snapshot.persistenceLabel}`,
+		`Tool catalog: ${snapshot.activeTools.length} of ${CHROME_DEVTOOLS_TOOL_NAMES.length} available · ${snapshot.persistenceLabel}`,
 		`Browser: ${browserLifecycleSummary()}`,
 		`Endpoint: ${devToolsEndpoint()}`,
 		...(snapshot.settingsWarning ? [`Settings warning: ${snapshot.settingsWarning}`] : []),
@@ -421,7 +421,7 @@ function buildToolReview(current: ToolWorkflowState) {
 			`Current available browser tools: ${current.accepted.size}/${CHROME_DEVTOOLS_TOOL_NAMES.length}`,
 			`Proposed available browser tools: ${current.draft.size}/${CHROME_DEVTOOLS_TOOL_NAMES.length}`,
 			"",
-			"Available to lazy-load after apply:",
+			"Available after apply:",
 			...(available.length > 0
 				? available.map((name) => `  - ${TOOL_PRESENTATION[name].label} (${name})`)
 				: ["  - none"]),
@@ -432,7 +432,8 @@ function buildToolReview(current: ToolWorkflowState) {
 				: ["  - none"]),
 			"",
 			"Other active Pi tools remain unchanged.",
-			"Newly available tools remain deferred until chrome_devtools_load selects them.",
+			"Native-capable models defer these tools until chrome_devtools_load selects them.",
+			"Other models expose available tools eagerly before the next model request.",
 			"The accepted availability policy is saved for future sessions.",
 		].join("\n"),
 	);

package/src/tool-selector.ts

@@ -14,6 +14,7 @@ import {
 	applyAvailableChromeDevtoolsTools,
 	availableChromeDevtoolsTools,
 	CHROME_DEVTOOLS_LOAD_TOOL_NAME,
+	chromeDevtoolsToolExposureMode,
 } from "./lazy-tools.js";
 import { state } from "./runtime.js";
 import { loadSettings, saveSettings, settingsFilePath } from "./settings.js";
@@ -49,7 +50,7 @@ export async function updateChromeDevtoolsTools(
 	if (result !== "saved" || generation !== state.sessionGeneration) return;
 	const status = await buildToolStatusMessage(pi);
 	if (generation !== state.sessionGeneration) return;
-	ctx.ui.notify(`Chrome DevTools lazy catalog ${action}.\n\n${status}`, "info");
+	ctx.ui.notify(`Chrome DevTools tool catalog ${action}.\n\n${status}`, "info");
 }
 
 export async function setSelectedChromeDevtoolsTools(
@@ -121,7 +122,11 @@ async function transactSelectedToolsNow(
 			const previousLoadedChromeTools = previousActiveTools.filter((name) =>
 				CHROME_DEVTOOLS_TOOL_NAMES.includes(name as ChromeDevToolsToolName),
 			);
-			pi.setActiveTools(unique([...currentNonChromeTools, ...previousLoadedChromeTools]));
+			const restoredChromeTools =
+				chromeDevtoolsToolExposureMode(pi) === "eager"
+					? previousAvailableTools
+					: previousLoadedChromeTools;
+			pi.setActiveTools(unique([...currentNonChromeTools, ...restoredChromeTools]));
 		} catch (caught) {
 			rollbackError = caught;
 		}
@@ -179,10 +184,11 @@ export async function buildToolStatusMessage(pi: ExtensionAPI) {
 	const persistedSetting = await persistedSettingLabel();
 	return sanitizeChromeDevtoolsDisplay(
 		[
-			`Chrome DevTools tools available to lazy-load: ${formatRuntimeStatus(summary)}`,
+			`Chrome DevTools tools available: ${formatRuntimeStatus(summary)}`,
+			`Tool exposure: ${chromeDevtoolsToolExposureMode(pi)}`,
 			`Loaded capability tools this session: ${summary.loadedChromeToolCount}/${CHROME_DEVTOOLS_TOOL_NAMES.length}`,
 			`Loader: ${pi.getActiveTools().includes(CHROME_DEVTOOLS_LOAD_TOOL_NAME) ? "active" : "inactive"}`,
-			`Persisted lazy catalog: ${persistedSetting}`,
+			`Persisted tool catalog: ${persistedSetting}`,
 			...browserSettingsStatusLines(),
 			...(state.settingsNotice ? [`Settings note: ${state.settingsNotice}`] : []),
 			`Other active tools preserved: ${summary.activeNonChromeToolCount}`,
@@ -289,9 +295,9 @@ export function buildCommandGuide() {
 		"/chrome-devtools quickstart — show endpoint and launch help",
 		"/chrome-devtools status — show tool and settings status",
 		"/chrome-devtools settings — edit browser connection settings",
-		"/chrome-devtools tools — choose tools available to lazy-load",
+		"/chrome-devtools tools — choose available Chrome DevTools tools",
 		"/chrome-devtools toggle|select — compatibility aliases for tools",
-		"/chrome-devtools enable|on — make all Chrome DevTools tools available to lazy-load",
+		"/chrome-devtools enable|on — make all Chrome DevTools tools available",
 		"/chrome-devtools disable|off — make all Chrome DevTools capability tools unavailable",
 	].join("\n");
 }