made slack bot notifier ai features more robust

Author: barrymichaeldoyle

package.json

@@ -11,7 +11,7 @@
   },
   "packageManager": "pnpm@10.33.0",
   "devDependencies": {
-    "@changesets/cli": "^2.30.0",
+    "@changesets/cli": "2.31.0",
     "@types/node": "25.6.0",
     "esbuild": "0.28.0",
     "knip": "6.4.1",

packages/notifier-bot/convex/aiSummary.ts

@@ -1,9 +1,14 @@
 import { type UpdateType } from '@patch-pulse/shared';
 import { type ReleaseEvidence } from './releaseEvidence';
+import { getTimeoutMs, withTimeout } from './async';
 
 const OPENAI_API_URL = 'https://api.openai.com/v1/responses';
 const DEFAULT_NANO_MODEL = 'gpt-5-nano';
 const DEFAULT_MINI_MODEL = 'gpt-5-mini';
+const OPENAI_SUMMARY_TIMEOUT_MS = getTimeoutMs(
+  'OPENAI_SUMMARY_TIMEOUT_MS',
+  15_000,
+);
 
 function buildSummaryPrompt(args: {
   packageName: string;
@@ -49,44 +54,52 @@ async function callOpenAiSummary(
   // Caller (summarizeReleaseEvidence) guards that the key exists before calling.
   const apiKey = process.env.OPENAI_API_KEY!;
 
-  const response = await fetch(OPENAI_API_URL, {
-    method: 'POST',
-    headers: {
-      'Content-Type': 'application/json',
-      Authorization: `Bearer ${apiKey}`,
-    },
-    body: JSON.stringify({
-      model,
-      input: [
-        {
-          role: 'system',
-          content: [
+  return withTimeout(
+    (async () => {
+      const response = await fetch(OPENAI_API_URL, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          Authorization: `Bearer ${apiKey}`,
+        },
+        body: JSON.stringify({
+          model,
+          input: [
+            {
+              role: 'system',
+              content: [
+                {
+                  type: 'input_text',
+                  text:
+                    'You summarize software releases for Slack. Use only the provided evidence. ' +
+                    'Do not speculate. Return a single plain-text sentence under 240 characters. ' +
+                    'If the evidence is insufficient, return exactly INSUFFICIENT.',
+                },
+              ],
+            },
             {
-              type: 'input_text',
-              text:
-                'You summarize software releases for Slack. Use only the provided evidence. ' +
-                'Do not speculate. Return a single plain-text sentence under 240 characters. ' +
-                'If the evidence is insufficient, return exactly INSUFFICIENT.',
+              role: 'user',
+              content: [{ type: 'input_text', text: prompt }],
             },
           ],
-        },
-        {
-          role: 'user',
-          content: [{ type: 'input_text', text: prompt }],
-        },
-      ],
-    }),
-  });
+        }),
+      });
 
-  if (!response.ok) {
-    throw new Error(`OpenAI API error ${response.status}`);
-  }
+      if (!response.ok) {
+        throw new Error(`OpenAI API error ${response.status}`);
+      }
 
-  const data = (await response.json()) as {
-    output_text?: string;
-  };
+      const data = (await response.json()) as {
+        output_text?: string;
+      };
 
-  return data.output_text?.trim() || null;
+      return data.output_text?.trim() || null;
+    })(),
+    {
+      label: `OpenAI summary request (${model})`,
+      timeoutMs: OPENAI_SUMMARY_TIMEOUT_MS,
+    },
+  );
 }
 
 export async function summarizeReleaseEvidence(args: {

packages/notifier-bot/convex/async.ts

@@ -0,0 +1,30 @@
+export function getTimeoutMs(envName: string, fallbackMs: number): number {
+  const rawValue = process.env[envName];
+  if (!rawValue) return fallbackMs;
+
+  const parsedValue = Number(rawValue);
+  return Number.isFinite(parsedValue) && parsedValue > 0
+    ? parsedValue
+    : fallbackMs;
+}
+
+export async function withTimeout<T>(
+  operation: Promise<T>,
+  args: {
+    label: string;
+    timeoutMs: number;
+  },
+): Promise<T> {
+  let timeoutId: ReturnType<typeof setTimeout> | undefined;
+  const timeoutPromise = new Promise<never>((_, reject) => {
+    timeoutId = setTimeout(() => {
+      reject(new Error(`${args.label} timed out after ${args.timeoutMs}ms`));
+    }, args.timeoutMs);
+  });
+
+  try {
+    return await Promise.race([operation, timeoutPromise]);
+  } finally {
+    if (timeoutId) clearTimeout(timeoutId);
+  }
+}

packages/notifier-bot/convex/polling.ts

@@ -80,10 +80,6 @@ export const checkForUpdates = internalAction({
       const version = getNpmLatestVersion(manifest);
       if (!version) continue;
 
-      await ctx.runMutation(internal.packages.touchLastChecked, {
-        packageId: pkg._id,
-      });
-
       const { status } = getDependencyStatus({
         packageName: pkg.name,
         currentVersion: pkg.currentVersion,
@@ -165,6 +161,10 @@ export const checkForUpdates = internalAction({
           channelMap.set(key, entry);
           updatesBySubscriber.set(sub.subscriberId, channelMap);
         }
+      } else {
+        await ctx.runMutation(internal.packages.touchLastChecked, {
+          packageId: pkg._id,
+        });
       }
     }