@pi-unipi/notify 0.1.6 → 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.6",
+  "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",
@@ -24,6 +24,7 @@
     "commands.ts",
     "settings.ts",
     "events.ts",
+    "summarize.ts",
     "types.ts",
     "platforms/*",
     "tui/*",

package/summarize.ts

@@ -0,0 +1,149 @@
+/**
+ * @pi-unipi/notify — Recap summarization
+ *
+ * Calls an LLM to summarize the last assistant message for push notifications.
+ * Supports multiple API formats based on the model's api type.
+ */
+
+const SYSTEM_PROMPT =
+  "Summarize this in one concise sentence for a push notification. Reply with ONLY the summary.";
+const MAX_INPUT_CHARS = 2000;
+const MAX_TOKENS = 100;
+const TIMEOUT_MS = 10_000;
+const FALLBACK_TRUNCATE_CHARS = 100;
+
+/**
+ * Summarize a message using an LLM.
+ *
+ * @param messageText - The assistant message text to summarize
+ * @param apiKey - API key for the provider
+ * @param baseUrl - Provider base URL (from Model.baseUrl)
+ * @param api - API type (from Model.api, e.g. "openai-completions")
+ * @param modelId - Model ID to use
+ * @returns Summarized text, or truncated original on failure
+ */
+export async function summarizeLastMessage(
+  messageText: string,
+  apiKey: string,
+  baseUrl: string,
+  api: string,
+  modelId: string,
+): Promise<string> {
+  // Truncate input if too long
+  const input =
+    messageText.length > MAX_INPUT_CHARS
+      ? messageText.slice(0, MAX_INPUT_CHARS) + "..."
+      : messageText;
+
+  try {
+    // Route to the correct API format
+    if (api === "anthropic-messages") {
+      return await callAnthropic(baseUrl, apiKey, modelId, input);
+    }
+    // Default: OpenAI-compatible (covers openai-completions, openai-responses, etc.)
+    return await callOpenAICompatible(baseUrl, apiKey, modelId, input);
+  } catch {
+    return fallbackSummary(messageText);
+  }
+}
+
+/** Call an OpenAI-compatible API (most providers) */
+async function callOpenAICompatible(
+  baseUrl: string,
+  apiKey: string,
+  modelId: string,
+  input: string,
+): Promise<string> {
+  const url = `${baseUrl.replace(/\/$/, "")}/chat/completions`;
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), TIMEOUT_MS);
+
+  try {
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${apiKey}`,
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({
+        model: modelId,
+        max_tokens: MAX_TOKENS,
+        messages: [
+          { role: "system", content: SYSTEM_PROMPT },
+          { role: "user", content: input },
+        ],
+      }),
+      signal: controller.signal,
+    });
+
+    clearTimeout(timeout);
+
+    if (!response.ok) {
+      return fallbackSummary(input);
+    }
+
+    const data = (await response.json()) as {
+      choices?: Array<{ message?: { content?: string } }>;
+    };
+
+    const summary = data.choices?.[0]?.message?.content?.trim();
+    return summary && summary.length > 0 ? summary : fallbackSummary(input);
+  } catch {
+    clearTimeout(timeout);
+    return fallbackSummary(input);
+  }
+}
+
+/** Call the Anthropic Messages API */
+async function callAnthropic(
+  baseUrl: string,
+  apiKey: string,
+  modelId: string,
+  input: string,
+): Promise<string> {
+  const url = `${baseUrl.replace(/\/$/, "")}/messages`;
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), TIMEOUT_MS);
+
+  try {
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "x-api-key": apiKey,
+        "anthropic-version": "2023-06-01",
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({
+        model: modelId,
+        max_tokens: MAX_TOKENS,
+        system: SYSTEM_PROMPT,
+        messages: [{ role: "user", content: input }],
+      }),
+      signal: controller.signal,
+    });
+
+    clearTimeout(timeout);
+
+    if (!response.ok) {
+      return fallbackSummary(input);
+    }
+
+    const data = (await response.json()) as {
+      content?: Array<{ type?: string; text?: string }>;
+    };
+
+    const textBlock = data.content?.find((b) => b.type === "text");
+    const summary = textBlock?.text?.trim();
+    return summary && summary.length > 0 ? summary : fallbackSummary(input);
+  } catch {
+    clearTimeout(timeout);
+    return fallbackSummary(input);
+  }
+}
+
+/** Truncate message as fallback when summarization fails */
+function fallbackSummary(messageText: string): string {
+  const trimmed = messageText.trim();
+  if (trimmed.length <= FALLBACK_TRUNCATE_CHARS) return trimmed;
+  return trimmed.slice(0, FALLBACK_TRUNCATE_CHARS) + "...";
+}

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 },
       };
     },
   });