@shanepadgett/tau-agent 0.44.1 → 0.45.1

package/extensions/tool-loader/index.ts

@@ -1,228 +1,16 @@
-import { defineTool, type ExtensionAPI, type SessionEntry } from "@earendil-works/pi-coding-agent";
-import { type Static, Type } from "typebox";
-import { registeredDeferredToolGroups, type DeferredToolGroupInfo } from "../../src/tool-loading/index.ts";
-import { emitTauEvent } from "../../shared/events.ts";
-import { BoundedTextResultBuilder } from "../../shared/bounded-text-result.ts";
-import { createTemporaryOutputStore } from "../../shared/temporary-output-store.ts";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 
-const loadToolsSchema = Type.Object(
-	{
-		capability: Type.String({
-			minLength: 1,
-			description: "Registered specialist group ID, such as web, image, appshot, or a package-provided group",
-		}),
-	},
-	{ additionalProperties: false },
-);
-
-type LoadToolsParams = Static<typeof loadToolsSchema>;
-
-interface LoadToolsDetails {
-	version: 1;
-	capability: string;
-	requestedToolNames: string[];
-	addedToolNames: string[];
-}
-
-const PENDING_TYPE = "tau.tool-loader.pending";
-const APPLIED_TYPE = "tau.tool-loader.applied";
-
-interface AppliedLoad {
-	pendingId: string;
-	names: string[];
-}
+const TOOL_SEARCH = "tool_search";
 
 export default function toolLoaderExtension(pi: ExtensionAPI): void {
-	let temporaryOutput = createTemporaryOutputStore();
-	let managed = false;
-	let allowedToolNames = new Map<string, ReadonlySet<string>>();
-	let managedToolNames = new Set<string>();
-
-	pi.registerTool(createLoadToolsTool(pi, []));
-
-	pi.on("session_start", async (_event, ctx) => {
-		temporaryOutput = createTemporaryOutputStore();
-		await temporaryOutput.start();
-		const groups = registeredDeferredToolGroups(pi);
-		pi.registerTool(createLoadToolsTool(pi, groups));
-
-		const initial = pi.getActiveTools();
-		const initialSet = new Set(initial);
-		allowedToolNames = new Map(
-			groups.map((group) => [group.id, new Set(group.toolNames.filter((name) => initialSet.has(name)))]),
-		);
-		managedToolNames = new Set(groups.flatMap((group) => group.toolNames));
-		managed = initialSet.has("load_tools") && groups.length > 0;
-		if (managed) restoreActiveTools(pi, initial, loadedCapabilities(ctx.sessionManager.getBranch(), groups), groups);
-	});
-	pi.on("session_shutdown", () => temporaryOutput.shutdown());
-
-	pi.on("session_tree", (_event, ctx) => {
-		if (managed) {
-			restoreActiveTools(
-				pi,
-				pi.getActiveTools(),
-				loadedCapabilities(ctx.sessionManager.getBranch(), registeredDeferredToolGroups(pi)),
-				registeredDeferredToolGroups(pi),
-			);
+	pi.on("session_start", (_event, ctx) => {
+		const tools = pi.getAllTools();
+		if (!tools.some((tool) => tool.exposure === "deferred")) return;
+		if (!tools.some((tool) => tool.name === TOOL_SEARCH)) {
+			ctx.ui.notify("Deferred tool groups need Pi's built-in tool_search extension, which is disabled.", "warning");
+			return;
 		}
+		const active = pi.getActiveTools();
+		if (!active.includes(TOOL_SEARCH)) pi.setActiveTools([...active, TOOL_SEARCH]);
 	});
-
-	pi.on("session_compact", (_event, ctx) => {
-		const branch = ctx.sessionManager.getBranch();
-		const applied = new Set(
-			branch.flatMap((entry) =>
-				entry.type === "custom" && entry.customType === APPLIED_TYPE ? [(entry.data as AppliedLoad).pendingId] : [],
-			),
-		);
-		for (const entry of branch) {
-			if (
-				entry.type !== "custom" ||
-				entry.customType !== PENDING_TYPE ||
-				applied.has(entry.id) ||
-				!Array.isArray(entry.data)
-			)
-				continue;
-			const names = entry.data.filter((name): name is string => typeof name === "string");
-			const allowed = new Set([...allowedToolNames.values()].flatMap((group) => [...group]));
-			pi.setActiveTools([...new Set([...pi.getActiveTools(), ...names.filter((name) => allowed.has(name))])]);
-			pi.appendEntry(APPLIED_TYPE, { pendingId: entry.id, names });
-		}
-	});
-
-	function createLoadToolsTool(pi: ExtensionAPI, groups: readonly DeferredToolGroupInfo[]) {
-		return defineTool<typeof loadToolsSchema, LoadToolsDetails>({
-			name: "load_tools",
-			label: "Load Tools",
-			description: `Load one registered Tau specialist tool group for the current session.${formatGroupCatalog(groups)}`,
-			promptSnippet: "Load a registered specialist tool group when the current tools cannot perform the task",
-			promptGuidelines: [
-				"Use load_tools before attempting a registered specialist capability whose tools are not currently available.",
-			],
-			parameters: loadToolsSchema,
-			async execute(_toolCallId, params: LoadToolsParams, signal, _onUpdate, ctx) {
-				const group = registeredDeferredToolGroups(pi).find((candidate) => candidate.id === params.capability);
-				if (group === undefined) {
-					throw new Error(
-						`Unknown specialist tool group: ${params.capability}.${formatGroupCatalog(registeredDeferredToolGroups(pi))}`,
-					);
-				}
-
-				const before = pi.getActiveTools();
-				const requested = [...group.toolNames];
-				const registered = new Set(pi.getAllTools().map((tool) => tool.name));
-				const allowed = allowedToolNames.get(group.id) ?? new Set<string>();
-				const loadable = requested.filter((name) => registered.has(name) && allowed.has(name));
-				if (loadable.length === 0) {
-					throw new Error(`No ${params.capability} tools are available in this session's tool configuration.`);
-				}
-
-				const beforeSet = new Set(before);
-				const next = [...before, ...loadable.filter((name) => !beforeSet.has(name))];
-				const nextSet = new Set(next);
-				let blocked: string | null = null;
-				emitTauEvent(pi, "tau:prompt.tools.check", {
-					ctx,
-					tools: pi.getAllTools().filter((tool) => nextSet.has(tool.name)),
-					reject(reason) {
-						blocked = reason;
-					},
-				});
-				if (blocked) {
-					pi.appendEntry(PENDING_TYPE, loadable);
-					return boundedResult(
-						`${blocked} ${params.capability} is queued for activation after successful compaction.`,
-						{ version: 1, capability: params.capability, requestedToolNames: requested, addedToolNames: [] },
-						signal,
-					);
-				}
-				pi.setActiveTools(next);
-				const after = pi.getActiveTools();
-				const addedToolNames = requested.filter((name) => !beforeSet.has(name) && after.includes(name));
-				const available = requested.filter((name) => after.includes(name));
-				const unavailable = requested.filter((name) => !after.includes(name));
-				const text =
-					addedToolNames.length > 0
-						? `Loaded ${params.capability} tools: ${addedToolNames.join(", ")}.`
-						: `${params.capability} tools are already loaded: ${available.join(", ")}.`;
-
-				return boundedResult(
-					unavailable.length ? `${text} Unavailable: ${unavailable.join(", ")}.` : text,
-					{
-						version: 1,
-						capability: params.capability,
-						requestedToolNames: requested,
-						addedToolNames,
-					},
-					signal,
-				);
-			},
-		});
-	}
-
-	async function boundedResult(text: string, details: LoadToolsDetails, signal: AbortSignal | undefined) {
-		const builder = new BoundedTextResultBuilder(temporaryOutput, "head");
-		try {
-			await builder.append(text);
-			signal?.throwIfAborted();
-			const result = await builder.finish();
-			return {
-				content: [{ type: "text" as const, text: result.content }],
-				details: { ...details, overflow: result.overflow },
-			};
-		} catch (error) {
-			await builder.abort();
-			throw error;
-		}
-	}
-
-	function restoreActiveTools(
-		pi: ExtensionAPI,
-		current: readonly string[],
-		loaded: ReadonlySet<string>,
-		groups: readonly DeferredToolGroupInfo[],
-	): void {
-		const next = current.filter((name) => !managedToolNames.has(name));
-		for (const group of groups) {
-			if (!loaded.has(group.id)) continue;
-			const allowed = allowedToolNames.get(group.id) ?? new Set<string>();
-			next.push(...group.toolNames.filter((name) => allowed.has(name)));
-		}
-		pi.setActiveTools([...new Set(next)]);
-	}
-}
-
-function formatGroupCatalog(groups: readonly DeferredToolGroupInfo[]): string {
-	if (groups.length === 0) return " No specialist groups are registered.";
-	const catalog = groups.map((group) => `${group.id}: ${group.description}`).join("; ");
-	return ` Registered groups: ${catalog}.`;
-}
-
-function loadedCapabilities(entries: readonly SessionEntry[], groups: readonly DeferredToolGroupInfo[]): Set<string> {
-	const loaded = new Set<string>();
-	for (const entry of entries) {
-		if (entry.type === "custom" && entry.customType === APPLIED_TYPE) {
-			const { names } = entry.data as AppliedLoad;
-			for (const group of groups) if (group.toolNames.some((name) => names.includes(name))) loaded.add(group.id);
-		}
-		if (entry.type !== "message") continue;
-		const message = entry.message;
-		if (message.role !== "toolResult" || message.toolName !== "load_tools" || message.isError === true) continue;
-		if (!isLoadToolsDetails(message.details)) continue;
-		if (message.details.addedToolNames.length > 0) loaded.add(message.details.capability);
-	}
-	return loaded;
-}
-
-function isLoadToolsDetails(value: unknown): value is LoadToolsDetails {
-	if (!value || typeof value !== "object") return false;
-	const details = value as Record<string, unknown>;
-	return (
-		details.version === 1 &&
-		typeof details.capability === "string" &&
-		Array.isArray(details.requestedToolNames) &&
-		details.requestedToolNames.every((name) => typeof name === "string") &&
-		Array.isArray(details.addedToolNames) &&
-		details.addedToolNames.every((name) => typeof name === "string")
-	);
 }

package/extensions/web/codesearch.ts

@@ -26,6 +26,7 @@ export function createCodeSearchTool(rowState: ToolRowStateStore) {
 	return defineTool<typeof codeSearchParams, CodeSearchDetails | undefined>({
 		name: "codesearch",
 		label: "Code Search",
+		annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: true },
 		description:
 			"Search Exa for API usage, code examples, and implementation-oriented documentation context. Use websearch for broad discovery and webfetch for a known URL. Use a separate research workflow when several searches, fetches, and synthesis are needed. Output is truncated to 2,000 lines or 50 KB.",
 		parameters: codeSearchParams,

package/extensions/web/webfetch.ts

@@ -177,6 +177,7 @@ export function createWebFetchTool(rowState: ToolRowStateStore) {
 	return defineTool<typeof webFetchParams, WebFetchDetails | undefined>({
 		name: "webfetch",
 		label: "Web Fetch",
+		annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: true },
 		description:
 			"Fetch a known HTTP(S) URL as Markdown, text, or HTML. Use webfetch when you already have a URL; use websearch for broad discovery and codesearch for implementation-oriented lookups. Use a separate research workflow when several searches, fetches, and synthesis are needed. Supports inline images, limits response bodies to 5 MB, and truncates text to 2,000 lines or 50 KB.",
 		parameters: webFetchParams,

package/extensions/web/websearch.ts

@@ -35,6 +35,7 @@ export function createWebSearchTool(rowState: ToolRowStateStore) {
 	return defineTool<typeof webSearchParams, WebSearchDetails | undefined>({
 		name: "websearch",
 		label: "Web Search",
+		annotations: { readOnlyHint: true, idempotentHint: true, openWorldHint: true },
 		description:
 			"Search the public web through Exa for current information and relevant pages. Use websearch for broad discovery, then webfetch for a known URL; use codesearch for implementation-oriented code and documentation context. Use a separate research workflow when several searches, fetches, and synthesis are needed. Output is truncated to 2,000 lines or 50 KB.",
 		parameters: webSearchParams,

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@shanepadgett/tau-agent",
-	"version": "0.44.1",
+	"version": "0.45.1",
 	"description": "Tau is a custom agentic harness built with pi extensions",
 	"type": "module",
 	"main": "./src/index.ts",
@@ -35,7 +35,7 @@
 	],
 	"dependencies": {
 		"@ast-grep/wasm": "0.45.3",
-		"@shanepadgett/tau-tui": "0.44.1",
+		"@shanepadgett/tau-tui": "0.45.1",
 		"@vscode/tree-sitter-wasm": "0.3.1",
 		"image-size": "2.0.4",
 		"smol-toml": "1.8.0",

package/shared/events.ts

@@ -1,11 +1,10 @@
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
-import type { Tool } from "@earendil-works/pi-ai";
 import type { ToolRowVisualState } from "./tool-row-state.js";
 import type { ScriptSourceStore } from "./script-source.ts";
 import type { FileInjectionRequest, PreparedFileInjection } from "../src/file-injection/index.ts";
 
 export type TauAgentEvents = {
-	/** @internal Soul's runtime-scoped prompt contributors. */
+	/** @internal Soul's runtime-scoped prompt contributors. Each source becomes one named Pi prompt section. */
 	"tau:prompt.sources": {
 		accept(source: {
 			key: string;
@@ -14,26 +13,13 @@ export type TauAgentEvents = {
 			read(ctx: ExtensionContext): Promise<string>;
 		}): void;
 	};
-	/** @internal Check a tool loadout before activation. */
-	"tau:prompt.tools.check": {
-		ctx: ExtensionContext;
-		tools: Tool[];
-		reject(reason: string): void;
-	};
-	/** @internal Exact projected Soul instructions, for prompt viewers. */
+	/** @internal Soul's complete instructions for the current turn, for prompt viewers. */
 	"tau:prompt.snapshot": { text: string };
 	"tau:agent.blocked": {
 		title?: string;
 		body?: string;
 		source?: string;
 	};
-	"tau:attention.hold.acquire": {
-		id: string;
-	};
-	"tau:attention.hold.release": {
-		id: string;
-		disposition: "notify" | "discard";
-	};
 	"tau:file-mutation.applied": {
 		source: "patch";
 		toolCallId: string;
@@ -49,10 +35,6 @@ export type TauAgentEvents = {
 			snapshotRanges?: Array<{ startLine: number; endLine: number }>;
 		}>;
 	};
-	/** @internal Runtime-scoped discovery for deferred tool groups. */
-	"tau:deferred-tool-group.request": {
-		accept(group: { id: string; description: string; toolNames: readonly string[] }): void;
-	};
 	/** @internal Runtime-scoped request for Explore-owned file preparation. */
 	"tau:file-injection.prepare": {
 		request: FileInjectionRequest;
@@ -103,10 +85,15 @@ interface TauEventSubscription {
 	stop(): void;
 }
 
-const tauEventSubscriptions = new WeakMap<
+type TauEventSubscriptionRegistry = WeakMap<
 	ExtensionAPI["events"],
 	Map<string, Map<keyof TauAgentEvents, TauEventSubscription>>
->();
+>;
+
+// Global and project installs load separate module instances but share one pi.events bus.
+const registryKey = Symbol.for("tau-agent.eventSubscriptions");
+const registryHost = globalThis as typeof globalThis & { [registryKey]?: TauEventSubscriptionRegistry };
+const tauEventSubscriptions: TauEventSubscriptionRegistry = (registryHost[registryKey] ??= new WeakMap());
 
 export function emitTauEvent<Name extends keyof TauAgentEvents>(
 	pi: EmitEventAPI,

package/shared/model-effort.ts

@@ -31,27 +31,31 @@ export interface EffortCandidateOptions {
 
 const MODEL_PREFERENCES: Record<ModelEffort, readonly ProviderPreference[]> = {
 	quick: [
+		{ provider: "openai-codex", models: [{ model: "gpt-6-luna", reasoning: "medium" }] },
+		{ provider: "openai", models: [{ model: "gpt-6-luna", reasoning: "medium" }] },
+		{ provider: "xai", models: [{ model: "grok-4.7", reasoning: "medium" }] },
+		{ provider: "anthropic", models: [{ model: "claude-sonnet-5-5", reasoning: "medium" }] },
 		{
-			provider: "openai-codex",
+			provider: "opencode-go",
 			models: [
-				{ model: "gpt-6-luna", reasoning: "medium" },
-				{ model: "gpt-5.6-luna", reasoning: "medium" },
+				{ model: "deepseek-v4.1-flash", reasoning: "high" },
+				{ model: "glm-5.3-flash", reasoning: "high" },
 			],
 		},
-		{ provider: "xai", models: [{ model: "grok-4.7", reasoning: "medium" }] },
-		{ provider: "anthropic", models: [{ model: "claude-sonnet-5", reasoning: "medium" }] },
+		{ provider: "openrouter", models: [{ model: "deepseek/deepseek-v4.1-flash", reasoning: "high" }] },
 	],
 	standard: [
 		{
 			provider: "openai-codex",
 			models: [
+				{ model: "gpt-6.1-sol", reasoning: "high" },
 				{ model: "gpt-6-sol", reasoning: "high" },
 				{ model: "gpt-6-luna", reasoning: "max" },
 				{ model: "gpt-5.6-luna", reasoning: "max" },
 			],
 		},
 		{ provider: "xai", models: [{ model: "grok-4.7", reasoning: "high" }] },
-		{ provider: "anthropic", models: [{ model: "claude-sonnet-5", reasoning: "high" }] },
+		{ provider: "anthropic", models: [{ model: "claude-sonnet-5-5", reasoning: "high" }] },
 	],
 	deep: [
 		{
@@ -61,8 +65,8 @@ const MODEL_PREFERENCES: Record<ModelEffort, readonly ProviderPreference[]> = {
 		{
 			provider: "anthropic",
 			models: [
-				{ model: "claude-opus-5.5", reasoning: "medium" },
-				{ model: "claude-fable-5.1", reasoning: "low" },
+				{ model: "claude-opus-5-5", reasoning: "medium" },
+				{ model: "claude-fable-5-1", reasoning: "low" },
 			],
 		},
 	],

package/shared/model-fallback/index.ts

@@ -1,6 +1,5 @@
 import { randomUUID } from "node:crypto";
 import {
-	normalizeContext,
 	type Api,
 	type AssistantMessage,
 	type Message,
@@ -20,6 +19,7 @@ const SEVEN_DAYS_MS = 604_800_000;
 
 interface GenerationContext {
 	ui: ExtensionContext["ui"];
+	modelRegistry: ExtensionContext["modelRegistry"];
 	signal: AbortSignal | undefined;
 }
 
@@ -40,32 +40,22 @@ export async function resolveCandidates(
 	const seen = new Set<string>();
 	const blocked = currentBlockedProviders(settings.cooldowns ?? {});
 
-	const add = async (model: Model<Api>, reasoning: ThinkingLevel | undefined): Promise<void> => {
+	const add = (model: Model<Api>, reasoning: ThinkingLevel | undefined): void => {
 		if (blocked.has(model.provider)) return;
 		const key = `${model.provider}/${model.id}`;
 		if (seen.has(key)) return;
 
-		const provider = ctx.modelRegistry.getProvider(model.provider);
-		if (!provider) return;
-		const auth = await ctx.modelRegistry.getApiKeyAndHeaders(model);
-		if (!auth.ok) return;
+		if (!ctx.modelRegistry.hasConfiguredAuth(model)) return;
 
 		seen.add(key);
-		candidates.push({
-			model,
-			provider,
-			apiKey: auth.apiKey,
-			headers: auth.headers,
-			env: auth.env,
-			reasoning,
-		});
+		candidates.push({ model, reasoning });
 	};
 
 	for (const preferred of preferredModels) {
 		const model = ctx.modelRegistry.find(preferred.provider, preferred.model);
-		if (model) await add(model, preferred.reasoning);
+		if (model) add(model, preferred.reasoning);
 	}
-	if (includeParentModel && ctx.model) await add(ctx.model, undefined);
+	if (includeParentModel && ctx.model) add(ctx.model, undefined);
 
 	if (candidates.length === 0) throw new Error("No authenticated model available for generation.");
 	return candidates;
@@ -253,19 +243,12 @@ function completeCandidate(
 	sessionId: string,
 	tools?: Tool[],
 ): Promise<AssistantMessage> {
-	return candidate.provider
-		.streamSimple(
-			candidate.model,
-			normalizeContext(tools ? { messages: [...messages], tools } : { messages: [...messages] }),
-			{
-				apiKey: candidate.apiKey,
-				headers: candidate.headers,
-				env: candidate.env,
-				signal: ctx.signal,
-				reasoning: candidate.reasoning,
-				sessionId,
-			},
-		)
+	return ctx.modelRegistry
+		.streamSimple(candidate.model, tools ? { messages: [...messages], tools } : { messages: [...messages] }, {
+			signal: ctx.signal,
+			reasoning: candidate.reasoning,
+			sessionId,
+		})
 		.result();
 }
 

package/shared/model-fallback/types.ts

@@ -1,10 +1,6 @@
-import type { Api, Model, Provider, ProviderEnv, ProviderHeaders, ThinkingLevel } from "@earendil-works/pi-ai";
+import type { Api, Model, ThinkingLevel } from "@earendil-works/pi-ai";
 
 export interface ModelCandidate {
 	model: Model<Api>;
-	provider: Provider;
-	apiKey: string | undefined;
-	headers: ProviderHeaders | undefined;
-	env: ProviderEnv | undefined;
 	reasoning: ThinkingLevel | undefined;
 }

package/shared/prompt-contributions.ts

@@ -3,8 +3,6 @@ import { emitTauEvent, onTauEventImmediately, type TauAgentEvents } from "./even
 
 type PromptSource = Parameters<TauAgentEvents["tau:prompt.sources"]["accept"]>[0];
 
-export type PromptValue = Pick<PromptSource, "key" | "section" | "refresh"> & { text: string };
-
 export function collectPromptSources(pi: ExtensionAPI): PromptSource[] {
 	const sources: PromptSource[] = [];
 	emitTauEvent(pi, "tau:prompt.sources", { accept: (source) => sources.push(source) });

package/src/tool-loading/index.ts

@@ -1,5 +1,4 @@
 import type { ExtensionAPI, ToolDefinition } from "@earendil-works/pi-coding-agent";
-import { emitTauEvent, onTauEventImmediately } from "../../shared/events.ts";
 
 export interface DeferredToolGroup {
 	id: string;
@@ -7,52 +6,16 @@ export interface DeferredToolGroup {
 	tools: readonly ToolDefinition[];
 }
 
-export type DeferredToolHost = Pick<ExtensionAPI, "events" | "on" | "registerTool">;
-
-export interface DeferredToolGroupInfo {
-	id: string;
-	description: string;
-	toolNames: readonly string[];
-}
-
-// Pi evaluates each extension in an isolated module graph, so module-local registries are not shared.
-const DEFERRED_TOOL_GROUP_REQUEST_EVENT = "tau:deferred-tool-group.request";
-
-export function registerDeferredToolGroup(pi: DeferredToolHost, group: DeferredToolGroup): void {
+/** Registers tools that stay out of the model's declarations until Pi's `tool_search` loads them. */
+export function registerDeferredToolGroup(pi: Pick<ExtensionAPI, "registerTool">, group: DeferredToolGroup): void {
 	const id = group.id.trim();
 	if (id.length === 0 || id !== group.id) throw new Error("Deferred tool group ID must be non-empty and trimmed");
 	if (group.description.trim().length === 0) throw new Error(`Deferred tool group ${id} needs a description`);
 	if (group.tools.length === 0) throw new Error(`Deferred tool group ${id} needs at least one tool`);
-
-	const toolNames = group.tools.map((tool) => tool.name);
-	if (new Set(toolNames).size !== toolNames.length) {
+	if (new Set(group.tools.map((tool) => tool.name)).size !== group.tools.length) {
 		throw new Error(`Deferred tool group ${id} contains duplicate tool names`);
 	}
-	if (toolNames.includes("load_tools")) throw new Error("load_tools cannot be part of a deferred tool group");
-
-	const groups = registeredDeferredToolGroups(pi);
-	if (groups.some((existing) => existing.id === id)) {
-		throw new Error(`Deferred tool group is already registered: ${id}`);
-	}
-	for (const existing of groups) {
-		if (toolNames.some((name) => existing.toolNames.includes(name))) {
-			throw new Error(`Deferred tool group ${id} overlaps an existing tool group`);
-		}
+	for (const tool of group.tools) {
+		pi.registerTool({ ...tool, exposure: "deferred", namespace: { name: id, description: group.description } });
 	}
-
-	for (const tool of group.tools) pi.registerTool(tool);
-	const info = { id, description: group.description, toolNames } satisfies DeferredToolGroupInfo;
-	onTauEventImmediately(pi, `deferred-tool-group.${id}`, DEFERRED_TOOL_GROUP_REQUEST_EVENT, ({ accept }) => {
-		accept(info);
-	});
-}
-
-export function registeredDeferredToolGroups(pi: Pick<ExtensionAPI, "events">): readonly DeferredToolGroupInfo[] {
-	const groups: DeferredToolGroupInfo[] = [];
-	emitTauEvent(pi, DEFERRED_TOOL_GROUP_REQUEST_EVENT, {
-		accept(group: DeferredToolGroupInfo) {
-			groups.push(group);
-		},
-	});
-	return groups;
 }