@llblab/pi-actors 0.40.1 → 0.41.1

package/index.ts

@@ -7,7 +7,7 @@
 
 import * as AsyncRuns from "./lib/async-runs.ts";
 import * as CommandTemplates from "./lib/command-templates.ts";
-import * as Inspector from "./lib/inspector.ts";
+import * as InspectorOverlay from "./lib/inspector-overlay.ts";
 import * as Observability from "./lib/observability.ts";
 import * as Paths from "./lib/paths.ts";
 import * as Pi from "./lib/pi.ts";
@@ -15,14 +15,16 @@ import * as Prompts from "./lib/prompts.ts";
 import * as Runtime from "./lib/runtime.ts";
 import * as Temp from "./lib/temp.ts";
 import * as Tools from "./lib/tools.ts";
+import * as ToolsResponse from "./lib/tools-response.ts";
 
 export default function toolRegistryExtension(pi: Pi.ExtensionAPI) {
   let runsAnimationInterval: NodeJS.Timeout | undefined;
   let runsNotifyTimeout: NodeJS.Timeout | undefined;
   let activeRunContext: Pi.ExtensionContext | undefined;
+  let lastRunWatcherDiagnosticId = 0;
   const runUi = Observability.createRunUiObservationState();
   const retirementAttempts = new Set<string>();
-  const actorInspector = Inspector.createActorInspectorControllerState();
+  const terminalNotificationsInFlight = new Set<string>();
   const getRunOwnerId = Pi.getSessionId;
   const retireCandidateRuns = (
     ctx: Pi.ExtensionContext,
@@ -47,39 +49,13 @@ export default function toolRegistryExtension(pi: Pi.ExtensionAPI) {
       "zz-pi-actors-runs",
       snapshot.status ? ctx.ui.theme.fg("dim", snapshot.status) : undefined,
     );
-    ctx.ui.setWidget(
-      "zz-pi-actors-comms",
-      actorInspector.visible
-        ? () => ({
-            invalidate() {},
-            render(width: number) {
-              return Inspector.renderActorInspectorPanel({
-                stateRoot: Paths.EXTENSION_RUNTIME_PATHS.runStateRoot,
-                state: actorInspector,
-                ownerId,
-                width,
-                style: {
-                  actor: (text: string) => ctx.ui.theme.fg("accent", text),
-                  muted: (text: string) => ctx.ui.theme.fg("dim", text),
-                  preview: (text: string) => ctx.ui.theme.fg("text", text),
-                  stripe: (text: string) => text,
-                  stripeAlt: (text: string) =>
-                    ctx.ui.theme.bg("customMessageBg", text),
-                  target: (text: string) => ctx.ui.theme.fg("success", text),
-                  type: (text: string) => ctx.ui.theme.fg("warning", text),
-                },
-              });
-            },
-          })
-        : undefined,
-      { placement: "belowEditor" },
-    );
     if (!notify) return;
     const notificationSink = Pi.createNotificationSink(pi, ctx);
     retireCandidateRuns(ctx, snapshot.summary);
     Observability.deliverRunTransitionNotifications(
       snapshot.transitions,
       notificationSink,
+      terminalNotificationsInFlight,
     );
     Observability.pruneRunUiObservationState(runUi, snapshot);
     if (!terminalOnly) {
@@ -91,22 +67,56 @@ export default function toolRegistryExtension(pi: Pi.ExtensionAPI) {
   };
   const closeRunWatchers = (): void => {
     runWatcher.close();
+    terminalReconciliation.close();
     if (runsNotifyTimeout) clearTimeout(runsNotifyTimeout);
     runsNotifyTimeout = undefined;
   };
-  const scheduleRunEventUpdate = (ctx: Pi.ExtensionContext): void => {
+  const reportRunWatcherDiagnostics = (ctx: Pi.ExtensionContext): void => {
+    for (const diagnostic of runWatcher.getDiagnostics()) {
+      if (diagnostic.id <= lastRunWatcherDiagnosticId) continue;
+      lastRunWatcherDiagnosticId = diagnostic.id;
+      ctx.ui.notify(
+        diagnostic.message,
+        diagnostic.code === "rearmed" ? "info" : "warning",
+      );
+    }
+  };
+  const scheduleRunEventUpdate = (): void => {
     if (runsNotifyTimeout) clearTimeout(runsNotifyTimeout);
     runsNotifyTimeout = setTimeout(() => {
+      const ctx = activeRunContext;
+      if (!ctx) return;
       runWatcher.refresh();
       updateRunUi(ctx, true);
+      reportRunWatcherDiagnostics(ctx);
     }, 50);
     runsNotifyTimeout.unref?.();
   };
   const runWatcher = Observability.createRunStateWatcher({
     stateRoot: Paths.EXTENSION_RUNTIME_PATHS.runStateRoot,
-    onChange: () =>
-      activeRunContext && scheduleRunEventUpdate(activeRunContext),
+    onChange: scheduleRunEventUpdate,
   });
+  const terminalReconciliation =
+    Observability.createRunTerminalReconciliationLoop({
+      onError: (error) => {
+        const ctx = activeRunContext;
+        if (!ctx) return;
+        const message = error instanceof Error ? error.message : String(error);
+        ctx.ui.notify(`Actor terminal reconciliation failed: ${message}`, "error");
+      },
+      reconcile: () => {
+        const ctx = activeRunContext;
+        if (!ctx) return;
+        Observability.reconcileRunTerminalNotifications({
+          inFlight: terminalNotificationsInFlight,
+          ownerId: getRunOwnerId(ctx),
+          sink: Pi.createNotificationSink(pi, ctx),
+          state: runUi,
+        });
+        reportRunWatcherDiagnostics(ctx);
+      },
+      refreshWatcher: () => runWatcher.refresh(),
+    });
   const actorToolDefinitions = new Map<string, Tools.ActorToolDefinition>();
   const withCurrentThinkingContext = <T extends Tools.ActorToolDefinition>(
     definition: T,
@@ -115,7 +125,7 @@ export default function toolRegistryExtension(pi: Pi.ExtensionAPI) {
     const execute = definition.execute as (...args: unknown[]) => unknown;
     return {
       ...definition,
-      execute: (...args: unknown[]) => {
+      execute: async (...args: unknown[]) => {
         const nextArgs = [...args];
         const ctx = nextArgs[4];
         if (ctx && typeof ctx === "object") {
@@ -124,7 +134,11 @@ export default function toolRegistryExtension(pi: Pi.ExtensionAPI) {
             getThinkingLevel: () => pi.getThinkingLevel(),
           };
         }
-        return execute(...nextArgs);
+        try {
+          return ToolsResponse.spaceToolResult(await execute(...nextArgs));
+        } catch (error) {
+          throw ToolsResponse.spaceToolError(error);
+        }
       },
     } as T;
   };
@@ -147,16 +161,22 @@ export default function toolRegistryExtension(pi: Pi.ExtensionAPI) {
     return { skillPaths };
   });
   pi.on("session_start", async (_event, ctx) => {
+    // Clear the pre-overlay widget after hot reloads from older pi-actors builds.
+    ctx.ui.setWidget("zz-pi-actors-comms", undefined);
     activeRunContext = ctx;
+    closeRunWatchers();
+    recipeReload.close();
     await Temp.prepareExtensionTempDir(Paths.EXTENSION_RUNTIME_PATHS.tempDir);
+    if (activeRunContext !== ctx) return;
     runtime.loadTools(ctx);
     updateRunUi(ctx, true, true);
-    closeRunWatchers();
-    recipeReload.close();
     runWatcher.refresh();
+    terminalReconciliation.start();
     recipeReload.watch(ctx);
     if (runsAnimationInterval) clearInterval(runsAnimationInterval);
-    runsAnimationInterval = setInterval(() => updateRunUi(ctx, false), 1000);
+    runsAnimationInterval = setInterval(() => {
+      if (activeRunContext === ctx) updateRunUi(ctx, false);
+    }, 1000);
     runsAnimationInterval.unref?.();
   });
   pi.on("session_shutdown", async () => {
@@ -166,40 +186,30 @@ export default function toolRegistryExtension(pi: Pi.ExtensionAPI) {
     closeRunWatchers();
     recipeReload.close();
   });
-  pi.registerCommand("actors-inspector-toggle", {
-    description: Inspector.ACTOR_INSPECTOR_COMMAND_DESCRIPTIONS.toggle,
-    handler: async (args, ctx) => {
-      const result = Inspector.handleActorInspectorToggle(actorInspector, args);
-      if (result.update) updateRunUi(ctx);
-      ctx.ui.notify(result.notify, result.type);
-    },
-  });
-  pi.registerCommand("actors-inspector-filter", {
-    description: Inspector.ACTOR_INSPECTOR_COMMAND_DESCRIPTIONS.filter,
-    handler: async (args, ctx) => {
-      const result = Inspector.handleActorInspectorFilter(actorInspector, args);
-      if (result.update) updateRunUi(ctx);
-      ctx.ui.notify(result.notify, result.type);
-    },
-  });
-  pi.registerCommand("actors-inspect", {
-    description: Inspector.ACTOR_INSPECTOR_COMMAND_DESCRIPTIONS.inspect,
-    handler: async (args, ctx) => {
-      const previews = Inspector.readActorInspectorPreviews(
-        Paths.EXTENSION_RUNTIME_PATHS.runStateRoot,
-        actorInspector.rows,
-        Inspector.getActorInspectorPreviewOptions(
-          actorInspector,
-          getRunOwnerId(ctx),
-        ),
-      );
-      const result = Inspector.handleActorInspectorInspect(
-        actorInspector,
-        args,
-        previews,
+  pi.registerCommand("actors-inspector", {
+    description: "Open the keyboard-driven actor inspector overlay",
+    handler: async (_args, ctx) => {
+      ctx.ui.setWidget("zz-pi-actors-comms", undefined);
+      await ctx.ui.custom<void>(
+        (tui, theme, _keybindings, done) =>
+          new InspectorOverlay.ActorInspectorOverlay({
+            done,
+            ownerId: getRunOwnerId(ctx),
+            stateRoot: Paths.EXTENSION_RUNTIME_PATHS.runStateRoot,
+            theme,
+            tui,
+          }),
+        {
+          overlay: true,
+          overlayOptions: {
+            anchor: "center",
+            width: "94%",
+            minWidth: 72,
+            maxHeight: "94%",
+            margin: 1,
+          },
+        },
       );
-      if (result.update) updateRunUi(ctx);
-      ctx.ui.notify(result.notify, result.type);
     },
   });
   pi.on("before_agent_start", async (event) => ({