@pi-unipi/notify 0.1.7 → 0.1.8

package/events.ts

@@ -56,10 +56,13 @@ export function registerEventListeners(
     const eventConfig = config.events[eventKey];
     if (!eventConfig?.enabled) continue;
 
-    const handler = async (payload: unknown) => {
+    const handler = (payload: unknown) => {
       const title = `Pi — ${def.label}`;
       const message = buildEventMessage(eventKey, payload);
-      await dispatchNotification(pi, title, message, eventConfig.platforms, eventKey, config);
+      // Fire-and-forget: don't block the event emitter
+      dispatchNotification(pi, title, message, eventConfig.platforms, eventKey, config).catch(
+        (err) => console.error(`[notify] Background notification failed for ${eventKey}:`, err)
+      );
     };
 
     (pi as any).on(def.hook, handler);
@@ -68,43 +71,44 @@ export function registerEventListeners(
   // agent_end — custom handler with session name and recap support
   const agentEndConfig = config.events["agent_end"];
   if (agentEndConfig?.enabled) {
-    const handler = async (payload: unknown) => {
+    const handler = (payload: unknown) => {
+      // Fire-and-forget: build message and dispatch in background,
+      // don't block agent_end from completing
       const sessionName = pi.getSessionName?.();
       const title = `Pi — ${BUILTIN_EVENTS.agent_end.label}`;
-      let message: string;
 
       if (config.recap.enabled) {
-        // Recap mode: summarize last assistant message
+        // Recap mode: summarize asynchronously, then dispatch
         const lastText = extractLastAssistantText(payload);
         if (lastText && sessionCtx?.modelRegistry) {
           const provider = extractProvider(config.recap.model);
           const modelId = extractModelId(config.recap.model);
           const model = sessionCtx.modelRegistry.find(provider, modelId);
           if (model) {
-            try {
-              const apiKeyResult = await sessionCtx.modelRegistry.getApiKeyAndHeaders(model);
-              const apiKey = apiKeyResult.ok ? (apiKeyResult as { apiKey?: string }).apiKey : undefined;
-              if (apiKey) {
-                const recap = await summarizeLastMessage(lastText, apiKey, model.baseUrl, model.api, modelId);
-                message = sessionName ? `${sessionName}: ${recap}` : recap;
-              } else {
-                message = buildAgentEndMessage(sessionName);
-              }
-            } catch {
-              message = buildAgentEndMessage(sessionName);
-            }
-          } else {
-            message = buildAgentEndMessage(sessionName);
+            sessionCtx.modelRegistry.getApiKeyAndHeaders(model)
+              .then((apiKeyResult) => {
+                const apiKey = apiKeyResult.ok ? (apiKeyResult as { apiKey?: string }).apiKey : undefined;
+                if (apiKey) {
+                  return summarizeLastMessage(lastText, apiKey, model.baseUrl, model.api, modelId)
+                    .then((recap) => sessionName ? `${sessionName}: ${recap}` : recap);
+                }
+                return buildAgentEndMessage(sessionName);
+              })
+              .catch(() => buildAgentEndMessage(sessionName))
+              .then((message) =>
+                dispatchNotification(pi, title, message, agentEndConfig.platforms, "agent_end", config)
+              )
+              .catch((err) => console.error("[notify] Background agent_end notification failed:", err));
+            return;
           }
-        } else {
-          message = buildAgentEndMessage(sessionName);
         }
-      } else {
-        // No recap: use session name based message
-        message = buildAgentEndMessage(sessionName);
       }
 
-      await dispatchNotification(pi, title, message, agentEndConfig.platforms, "agent_end", config);
+      // No recap or recap unavailable: dispatch immediately in background
+      const message = buildAgentEndMessage(sessionName);
+      dispatchNotification(pi, title, message, agentEndConfig.platforms, "agent_end", config).catch(
+        (err) => console.error("[notify] Background agent_end notification failed:", err)
+      );
     };
 
     (pi as any).on("agent_end", handler);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-unipi/notify",
-  "version": "0.1.7",
+  "version": "0.1.8",
   "description": "Cross-platform notification extension for Pi — native OS, Gotify, and Telegram notifications for agent lifecycle events",
   "type": "module",
   "license": "MIT",

package/tools.ts

@@ -9,7 +9,6 @@ import { Type } from "@sinclair/typebox";
 import { NOTIFY_TOOLS } from "@pi-unipi/core";
 import { loadConfig } from "./settings.js";
 import { dispatchNotification } from "./events.js";
-import type { NotifyDispatchResult } from "./types.js";
 
 /** Schema for notify_user tool parameters */
 const NotifyUserSchema = Type.Object({
@@ -43,7 +42,7 @@ export function registerNotifyTools(pi: ExtensionAPI): void {
       "Send a notification to the user's configured platforms (native OS, Gotify, Telegram, ntfy). " +
       "Use for critical errors, completion of long-running tasks, or when the user explicitly asked to be notified.",
     parameters: NotifyUserSchema,
-    async execute(_toolCallId, params, _signal, _onUpdate, ctx: ExtensionContext) {
+    async execute(_toolCallId, params, _signal, _onUpdate, _ctx: ExtensionContext) {
       const {
         message,
         title,
@@ -64,32 +63,26 @@ export function registerNotifyTools(pi: ExtensionAPI): void {
       // Resolve platforms — use params.platforms or global defaults
       const notifPlatforms = platforms || config.defaultPlatforms;
 
-      // Dispatch notification
-      const result: NotifyDispatchResult = await dispatchNotification(
+      // Fire-and-forget: dispatch in background so the tool doesn't block the agent
+      dispatchNotification(
         pi,
         notifTitle,
         message,
         notifPlatforms,
         "agent_tool",
         config
-      );
-
-      // Format result
-      const platformResults = result.results.map(
-        (r) => `${r.platform}: ${r.success ? "✓ sent" : `✗ ${r.error || "failed"}`}`
+      ).catch((err) =>
+        console.error("[notify] Background notify_user dispatch failed:", err)
       );
 
       return {
         content: [
           {
             type: "text" as const,
-            text: `Notification sent to ${result.results.length} platform(s):\n${platformResults.join("\n")}`,
+            text: `Notification sending to ${notifPlatforms.length} platform(s): ${notifPlatforms.join(", ")}`,
           },
         ],
-        details: {
-          platforms: result.results.map((r) => r.platform),
-          allSuccess: result.allSuccess,
-        },
+        details: { platforms: notifPlatforms },
       };
     },
   });