pi-lazy-extensions 0.1.10 → 0.1.12

package/README.md

@@ -15,6 +15,21 @@ _ToolSearch-style proxy tool — extensions only load when you need them._
 
 ---
 
+## Pi 1.0 compatibility (0.1.12)
+
+Tested against Pi **1.0.0** with exact SDK development pins and wildcard host peers.
+Lazy entrypoints now force Jiti transpilation: native ESM must not bypass mapped host constructors. Failed entrypoint evaluation is not retried with native import, and API interception restores exact original methods. Host probes cover TS/ESM identity, callable-only idle withdrawal/reactivation and native nested execution.
+
+Run `bun run test:host` for the offline real-host regression. Set `PI1_HOST_PACKAGE` to an installed Pi package directory and `PI1_HOST_ENTRY=bundle` to test its bundled CLI runtime.
+
+## Pi 0.99 compatibility (0.1.11)
+
+Tested with Pi **0.99.0**. Host-provided Pi packages and TypeBox are peers (`*`), not bundled runtime dependencies; development uses exact Pi 0.99.0 pins and host-compatible TypeBox where needed.
+
+Lazy modules reuse Pi's exact extension-loader virtual modules (SDK and bundled CLI), including import-only ESM/compat exports; they never import a second physical copy of the host runtime. Idle unload withdraws `codemode`/`deferred` tools with native `hidden` exposure; reactivation restores their original exposure without rerunning factories.
+
+Run `bun run test:host` for the offline real-host load, native codemode/nested-call, module-identity and reload checks. Set `PI1_HOST_PACKAGE` to an installed Pi package directory to test that host explicitly; add `PI1_HOST_ENTRY=bundle` to check the bundled CLI runtime's constructors.
+
 ## The Problem
 
 Every extension in `~/.pi/agent/extensions/` loads at startup. If you have many extensions, they all register their tools, commands, and event handlers immediately — even if you rarely use them. This clutters the tool list and wastes resources.
@@ -154,12 +169,12 @@ After `ext({ activate: "todo" })`, the `todo` extension's tools become directly
 
 ### Limitations
 
-- **No full unloading:** Once an extension's factory runs, its event handlers are permanent. Idle unloading only removes tools from the active set.
+- **No full unloading:** Idle unloading does not unsubscribe the extension's handlers. Direct tools leave the active set; codemode/deferred tools are re-registered as hidden so native nested dispatch cannot reach them.
 - **Shortcuts, flags, and message renderers persist:** These registrations have no deactivate/remove API in the current ExtensionAPI. They remain active even after idle-unload. The `ext` status display shows counts of these for awareness.
 - **`sourceInfo` attribution:** Tools registered by lazy-loaded extensions will show the `pi-lazy-extensions` extension's `sourceInfo`, not the original extension's. This is because `pi.registerTool()` stamps each tool with the `sourceInfo` of the *extension that made the call* — and since the lazy extension's factory receives the same `ExtensionAPI` as `pi-lazy-extensions`, all registered tools are attributed to `pi-lazy-extensions`. There is no SDK API to override this.
 - **`/ext` command vs `ext` tool:** The `/ext` command uses `ctx.ui.notify()` for output, which may truncate large results. For rich output (search results, detailed status), prefer the `ext` tool interface which renders properly in the TUI.
 - **`session_start` handlers never fire for the current session:** When a lazy extension is activated mid-session, any `session_start` handlers it registers will not fire until the next session or `/reload`. Extensions that depend on `session_start` for initialization (reading config, setting up state) may not work correctly when lazy-loaded. The `ext` tool displays a warning when this is detected.
-- **Duplicate tool names:** If a lazy extension registers a tool with the same name as an already-registered tool, pi's "first registration wins" policy silently skips it. The `ext` tool displays a warning when this is detected during activation.
+- **Duplicate tool names:** The loader skips names already registered before activation and reports a warning. This guard matters in Pi 0.99: tools sharing our API owner would otherwise replace each other on re-registration.
 
 ---
 
@@ -204,7 +219,7 @@ Lazy extensions are loaded via `jiti` — the same TypeScript/ESM transpiler tha
 - `@earendil-works/pi-coding-agent`
 - `@earendil-works/pi-agent-core`
 - `@earendil-works/pi-tui`
-- `@earendil-works/pi-ai` (and `@earendil-works/pi-ai/oauth`)
+- `@earendil-works/pi-ai` (mapped to the host compat entrypoint), `/compat`, `/oauth`, and `/providers/all`
 - `@sinclair/typebox` (legacy alias)
 
 This ensures lazy extensions can use the same imports as normally-loaded extensions. If jiti is unavailable (e.g. stripped from the runtime), the loader falls back to raw `import()`, which only works for `.js` files without SDK imports.

package/index.ts

@@ -53,7 +53,7 @@ export default function lazyExtensions(pi: ExtensionAPI) {
       return;
     }
     collisionChecked = true;
-    if (existingTools.some(t => t.name === "ext")) {
+    if (existingTools.some(t => t.name === "ext" && t.description !== PROXY_TOOL_DESCRIPTION)) {
       console.error(
         "pi-lazy-extensions: another extension already registered a tool named 'ext'. " +
         "The proxy tool will not be available. Use the /ext command instead, " +

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-lazy-extensions",
-  "version": "0.1.10",
+  "version": "0.1.12",
   "description": "Lazy-load pi extensions on demand via a ToolSearch-style proxy tool",
   "type": "module",
   "license": "MIT",
@@ -28,13 +28,17 @@
     "LICENSE"
   ],
   "dependencies": {
-    "jiti": "2.7.0",
-    "typebox": "1.1.38"
+    "jiti": "2.7.0"
   },
   "peerDependencies": {
-    "@earendil-works/pi-coding-agent": ">=0.74.0"
+    "@earendil-works/pi-coding-agent": "*",
+    "@earendil-works/pi-ai": "*",
+    "@earendil-works/pi-agent-core": "*",
+    "@earendil-works/pi-tui": "*",
+    "typebox": "*"
   },
   "scripts": {
+    "test:host": "node scripts/pi1-host.mjs",
     "test": "vitest run",
     "test:watch": "vitest",
     "test:coverage": "vitest run --coverage",
@@ -49,13 +53,16 @@
     "knip": "6.14.1",
     "typescript": "6.0.3",
     "vitest": "4.1.7",
-    "@earendil-works/pi-coding-agent": "0.87.0"
+    "@earendil-works/pi-coding-agent": "1.0.0",
+    "@earendil-works/pi-ai": "1.0.0",
+    "@earendil-works/pi-agent-core": "1.0.0",
+    "@earendil-works/pi-tui": "1.0.0",
+    "typebox": "1.3.27"
   },
   "overrides": {
     "brace-expansion": "5.0.6",
     "fast-xml-builder": "1.2.0",
     "protobufjs": "8.4.0",
-    "ws": "8.20.1",
-    "@earendil-works/pi-coding-agent": "0.87.0"
+    "ws": "8.20.1"
   }
 }

package/registry.ts

@@ -2,16 +2,27 @@
  * Extension registry - loads and tracks lazy extensions.
  *
  * This is the core of pi-lazy-extensions. It handles:
- * - Dynamic loading of extensions via jiti (or import()) + factory(pi)
+ * - Dynamic loading of extensions via host-mapped jiti + factory(pi)
  * - Tracking registered tools/commands per extension
  * - Idle timeout unloading
  * - Deduplication guards
  */
 
+import { readFile } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import type { ActivationResult, LazyExtensionsState } from "./types.js";
 import { resolveExtensionPath } from "./config.js";
-import { fileURLToPath } from "node:url";
+// These imports are mapped by Pi to its live modules (including bundled CLI).
+import * as hostCodingAgent from "@earendil-works/pi-coding-agent";
+import * as hostAgentCore from "@earendil-works/pi-agent-core";
+import * as hostAi from "@earendil-works/pi-ai/compat";
+import * as hostOauth from "@earendil-works/pi-ai/oauth";
+import * as hostProviders from "@earendil-works/pi-ai/providers/all";
+import * as hostTui from "@earendil-works/pi-tui";
+import * as hostTypebox from "typebox";
+import * as hostCompile from "typebox/compile";
+import * as hostValue from "typebox/value";
 
 const FAILURE_BACKOFF_MS = 60 * 1000;
 
@@ -47,8 +58,11 @@ export async function activateExtension(
   // factory(pi) call.
   if (extState.factoryCalled) {
     const currentActive = new Set(pi.getActiveTools());
+    for (const definition of extState.toolDefinitions ?? []) {
+      if (definition.exposure === "codemode" || definition.exposure === "deferred") pi.registerTool(definition);
+    }
     const restored: string[] = [];
-    for (const toolName of extState.registeredTools) {
+    for (const toolName of extState.activeBeforeUnload ?? extState.registeredTools) {
       if (!currentActive.has(toolName)) {
         restored.push(toolName);
       }
@@ -142,36 +156,41 @@ async function performActivation(
   const interceptedFlags: string[] = [];
   const interceptedRenderers: string[] = [];
   const interceptedTools: string[] = [];
+  const definitions = new Map<string, Parameters<ExtensionAPI["registerTool"]>[0]>();
   const interceptedEvents: string[] = [];
 
-  const origRegisterShortcut = (pi as any).registerShortcut?.bind(pi);
-  const origRegisterFlag = (pi as any).registerFlag?.bind(pi);
-  const origRegisterMessageRenderer = (pi as any).registerMessageRenderer?.bind(pi);
-  const origRegisterTool = pi.registerTool.bind(pi);
-  const origOn = pi.on.bind(pi);
+  const origRegisterShortcut = (pi as any).registerShortcut;
+  const origRegisterFlag = (pi as any).registerFlag;
+  const origRegisterMessageRenderer = (pi as any).registerMessageRenderer;
+  const origRegisterTool = pi.registerTool;
+  const origOn = pi.on;
 
   (pi as any).registerShortcut = (shortcut: string, options: any) => {
     interceptedShortcuts.push(shortcut);
-    origRegisterShortcut?.(shortcut, options);
+    origRegisterShortcut?.call(pi, shortcut, options);
   };
   (pi as any).registerFlag = (flagName: string, options: any) => {
     interceptedFlags.push(flagName);
-    origRegisterFlag?.(flagName, options);
+    origRegisterFlag?.call(pi, flagName, options);
   };
   (pi as any).registerMessageRenderer = (customType: string, renderer: any) => {
     interceptedRenderers.push(customType);
-    origRegisterMessageRenderer?.(customType, renderer);
+    origRegisterMessageRenderer?.call(pi, customType, renderer);
   };
   pi.registerTool = (tool: any) => {
     interceptedTools.push(tool.name);
-    origRegisterTool(tool);
+    // Lazy factories share our API owner. In 1.0 re-registering would replace
+    // that owner's tool, not silently lose a collision; preserve existing tools.
+    if (toolsBefore.has(tool.name)) return;
+    definitions.set(tool.name, tool);
+    origRegisterTool.call(pi, tool);
   };
   // 0.86.0: pi.on returns an unsubscribe function and its event name is a
   // closed overload set, so the generic string-typed proxy is asserted to
   // ExtensionAPI["on"]. The `never` cast lets the bound overload set resolve.
   pi.on = ((event: string, handler: any) => {
     interceptedEvents.push(event);
-    return origOn(event as never, handler);
+    return origOn.call(pi, event as never, handler);
   }) as ExtensionAPI["on"];
 
   const extPath = resolveExtensionPath(extState.config.path, state.baseDir);
@@ -194,6 +213,7 @@ async function performActivation(
     const toolsAfter = pi.getAllTools().map((t: any) => t.name as string);
     const newTools = toolsAfter.filter(t => !toolsBefore.has(t));
     extState.registeredTools = newTools;
+    extState.toolDefinitions = newTools.flatMap(name => definitions.has(name) ? [definitions.get(name)!] : []);
 
     // Diff commands the same way
     const commandsAfter = pi.getCommands().map((c: any) => c.name as string);
@@ -251,110 +271,61 @@ async function performActivation(
   }
 }
 
-/**
- * Build the jiti alias map that mirrors pi's own extension loader.
- *
- * Pi bundles core packages (typebox, @earendil-works/pi-ai, etc.) and resolves
- * them via aliases when loading extensions with jiti. Without these aliases,
- * extensions that `import { Type } from "typebox"` or import from
- * `@earendil-works/pi-coding-agent` will fail with module-not-found errors.
- *
- * We resolve the same packages via import.meta.resolve() which works
- * because pi-lazy-extensions itself depends on @earendil-works/pi-coding-agent
- * (the peer dependency is installed), and typebox is bundled by pi.
- */
-let _jitiAliases: Record<string, string> | undefined;
-
-function buildJitiAliases(): Record<string, string> {
-  if (_jitiAliases) return _jitiAliases;
-
-  const aliases: Record<string, string> = {};
-
-  // Core pi packages that extensions commonly import
-  const piPackages = [
-    "@earendil-works/pi-coding-agent",
-    "@earendil-works/pi-agent-core",
-    "@earendil-works/pi-tui",
-    "@earendil-works/pi-ai",
-    "@earendil-works/pi-ai/oauth",
-  ] as const;
-
-  for (const pkg of piPackages) {
-    try {
-      aliases[pkg] = fileURLToPath(import.meta.resolve(pkg));
-    } catch {
-      // Package not available in this environment — skip
-    }
-  }
-
-  // typebox and its subpath exports (most extensions use `import { Type } from "typebox"`)
-  const typeboxSpecs = ["typebox", "typebox/compile", "typebox/value"] as const;
-  for (const spec of typeboxSpecs) {
-    try {
-      aliases[spec] = fileURLToPath(import.meta.resolve(spec));
-    } catch {
-      // typebox not available — skip
-    }
-  }
-
-  // Alias legacy @sinclair/typebox to the same entries (some extensions still use it)
-  if (aliases["typebox"]) {
-    aliases["@sinclair/typebox"] = aliases["typebox"];
-  }
-  if (aliases["typebox/compile"]) {
-    aliases["@sinclair/typebox/compile"] = aliases["typebox/compile"];
-  }
-  if (aliases["typebox/value"]) {
-    aliases["@sinclair/typebox/value"] = aliases["typebox/value"];
+/** Reuse the exact host objects, not a second installation beside a bundled
+ * CLI. Virtual modules also work when managed host peers are not on disk. */
+let hostModules: Record<string, unknown> | undefined;
+function getHostModules(): Record<string, unknown> {
+  if (hostModules) return hostModules;
+  hostModules = {
+    "@earendil-works/pi-coding-agent": hostCodingAgent,
+    "@earendil-works/pi-agent-core": hostAgentCore,
+    "@earendil-works/pi-ai": hostAi,
+    "@earendil-works/pi-ai/compat": hostAi,
+    "@earendil-works/pi-ai/oauth": hostOauth,
+    "@earendil-works/pi-ai/providers/all": hostProviders,
+    "@earendil-works/pi-tui": hostTui,
+    typebox: hostTypebox, "typebox/compile": hostCompile, "typebox/value": hostValue,
+    "@sinclair/typebox": hostTypebox,
+    "@sinclair/typebox/compile": hostCompile,
+    "@sinclair/typebox/value": hostValue,
+  };
+  for (const [key, value] of Object.entries(hostModules)) {
+    if (key.startsWith("@earendil-works/pi-")) hostModules[key.replace("@earendil-works/", "@mariozechner/")] = value;
   }
-
-  _jitiAliases = aliases;
-  return aliases;
+  return hostModules;
 }
 
-/**
- * Reset cached jiti aliases (for testing or after module changes).
- */
-export function resetJitiAliases(): void {
-  _jitiAliases = undefined;
-}
+/** Retained test/public reset name; the cache now holds host virtual modules. */
+export function resetJitiAliases(): void { hostModules = undefined; }
 
 /**
  * Load an extension module and extract its default factory function.
  *
- * Tries jiti first (for TypeScript support and module alias resolution),
- * then falls back to raw import() for .js files or when jiti is unavailable.
+ * Jiti is required for both JS and TS. Never retry a failed evaluation with
+ * native import: it can execute side effects twice and bypass host mapping.
  *
- * Jiti is configured with the same alias map that pi's own extension loader
- * uses, so extensions can import from `typebox`, `@earendil-works/pi-coding-agent`,
- * etc. just like they would in a normally-loaded extension.
+ * Jiti receives the same live module objects as Pi's own extension loader,
+ * so lazy imports preserve class identity in both SDK and bundled CLI hosts.
  */
 async function loadExtensionFactory(
   extPath: string,
 ): Promise<((pi: ExtensionAPI) => void | Promise<void>) | undefined> {
-  // Attempt 1: jiti — handles .ts and provides SDK-compatible module aliases
-  try {
-    const { createJiti } = await import("jiti");
-    const jiti = createJiti(import.meta.url, {
-      moduleCache: false,
-      alias: buildJitiAliases(),
-    });
-    const mod = await jiti.import(extPath, { default: true });
-    if (typeof mod === "function") {
-      return mod as (pi: ExtensionAPI) => void | Promise<void>;
-    }
-    if (typeof (mod as any)?.default === "function") {
-      return (mod as any).default as (pi: ExtensionAPI) => void | Promise<void>;
-    }
-    return undefined;
-  } catch {
-    // jiti unavailable or failed — fall through to raw import
-  }
-
-  // Attempt 2: raw import() — works for .js files, no TypeScript support
-  const mod = await import(extPath);
-  if (typeof mod.default === "function") {
-    return mod.default as (pi: ExtensionAPI) => void | Promise<void>;
+  const { createJiti } = await import("jiti");
+  const jiti = createJiti(import.meta.url, {
+    moduleCache: false,
+    virtualModules: getHostModules(),
+    tryNative: false,
+  });
+  // Jiti 2.7 treats .mjs (and type:module .js) as native even with
+  // tryNative:false. Force the entrypoint through its mapped evaluator so
+  // bundled hosts never patch a second SDK and evaluation errors are not retried.
+  const filename = fileURLToPath(jiti.esmResolve(extPath));
+  const mod = await jiti.evalModule(await readFile(filename, "utf8"), {
+    filename, async: true, forceTranspile: true,
+  });
+  if (typeof mod === "function") return mod as (pi: ExtensionAPI) => void | Promise<void>;
+  if (typeof (mod as any)?.default === "function") {
+    return (mod as any).default as (pi: ExtensionAPI) => void | Promise<void>;
   }
   return undefined;
 }
@@ -447,7 +418,15 @@ function idleUnloadExtension(name: string, state: LazyExtensionsState, pi: Exten
   // Keep extState.registeredTools intact so reactivation can restore them
   // without re-calling factory(pi) (which would double-register event handlers).
   const activeTools = pi.getActiveTools();
+  extState.activeBeforeUnload = activeTools.filter(t => extState.registeredTools.includes(t));
   const remaining = activeTools.filter(t => !extState.registeredTools.includes(t));
+  // Removing an active name does not withdraw codemode/deferred tools in 1.0.
+  // Hidden exposure also removes them from ctx.tools / native nested dispatch.
+  for (const definition of extState.toolDefinitions ?? []) {
+    if (definition.exposure === "codemode" || definition.exposure === "deferred") {
+      pi.registerTool({ ...definition, exposure: "hidden" });
+    }
+  }
   pi.setActiveTools(remaining);
 
   extState.loaded = false;

package/types.ts

@@ -2,6 +2,8 @@
  * Types for the pi-lazy-extensions package.
  */
 
+import type { ToolDefinition } from "@earendil-works/pi-coding-agent";
+
 /** Lifecycle mode for a lazy extension. */
 export type ExtensionLifecycle = "lazy" | "eager" | "keep-alive";
 
@@ -85,6 +87,12 @@ export interface LoadedExtensionState {
   /** Names of tools registered by this extension (populated after load). */
   registeredTools: string[];
 
+  /** Original definitions, retained to withdraw callable tools with native hidden exposure. */
+  toolDefinitions?: ToolDefinition[];
+
+  /** Model declarations selected immediately before idle withdrawal. */
+  activeBeforeUnload?: string[];
+
   /** Names of commands registered by this extension (populated after load). */
   registeredCommands: string[];