create-loopengine 0.1.62 → 0.1.64

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-loopengine",
-  "version": "0.1.62",
+  "version": "0.1.64",
   "description": "Scaffold a new loopengine agent project — a runnable HTTP server with one example agent, in your own repo.",
   "license": "MIT",
   "type": "module",

package/template/_gitignore

@@ -2,6 +2,8 @@ node_modules
 dist
 .sessions
 .checkpoints
+# Slack threads matched to their requests (agents/<name>/.messaging).
+.messaging
 .scheduler
 .env
 *.log

package/template/adapters/http.ts

@@ -129,6 +129,10 @@ import {
   replyInSlack,
   slackOutcomeText,
   verifySlackRequest,
+  firstSighting,
+  handleInboundMessage,
+  createSlackConnector,
+  parseSlackEvent,
   removeAgentNotifier,
   saveAgentNotifier,
   testAgentNotifier,
@@ -2350,6 +2354,10 @@ async function answerPendingQuestion(res: ServerResponse, pendingId: string, bod
  * resumeAgent(), through the same durable sessions.withSession append
  * path any other turn goes through. */
 async function respondAfterResolution(res: ServerResponse, finalCheckpoint: TurnCheckpoint): Promise<void> {
+  await tracked(() => respondAfterResolutionNow(res, finalCheckpoint))
+}
+
+async function respondAfterResolutionNow(res: ServerResponse, finalCheckpoint: TurnCheckpoint): Promise<void> {
   if (Object.keys(finalCheckpoint.outstanding).length > 0) {
     res.writeHead(200, { 'content-type': 'application/json' }).end(
       JSON.stringify({ resolved: true, outstanding: Object.keys(finalCheckpoint.outstanding).length }),
@@ -2584,11 +2592,24 @@ function exitIfCodeChanged(res: ServerResponse): void {
 // checks before stopping an idle server, so it never stops one mid-turn.
 let openStreams = 0
 let lastRequestAt = Date.now()
+// Work still running after its request was answered (a Slack thread reply
+// being answered, a run resumed after a decision), so a host never
+// suspends this server in the middle of it.
+let backgroundWork = 0
+
+async function tracked<T>(fn: () => Promise<T>): Promise<T> {
+  backgroundWork++
+  try {
+    return await fn()
+  } finally {
+    backgroundWork--
+  }
+}
 
 async function handleActivityGet(res: ServerResponse): Promise<void> {
   res.writeHead(200, { 'content-type': 'application/json' }).end(
     JSON.stringify({
-      inFlightTurns: sessionTurns.size + scheduler.running,
+      inFlightTurns: sessionTurns.size + scheduler.running + backgroundWork,
       scheduledRuns: scheduler.running,
       // When the next scheduled task is due — wake this server by then
       // (POST /internal/scheduler/tick) if it's been stopped while idle.
@@ -2666,7 +2687,7 @@ function captureResponse(): { res: ServerResponse; done: Promise<{ status: numbe
   return { res: res as unknown as ServerResponse, done }
 }
 
-// A Slack app's Interactivity Request URL (core/slack-interactions.ts):
+// A Slack app's Interactivity Request URL (core/messaging/connectors/slack/interactions.ts):
 // Approve/Deny, an answer option, or the "Other…" modal, from a Slack
 // notifier's message. Outside the admin login on purpose — Slack can't
 // send it — and verified with that agent's Slack signing secret instead.
@@ -2705,6 +2726,52 @@ async function handleSlackInteraction(req: IncomingMessage, res: ServerResponse,
   }
 }
 
+// A Slack app's Event Subscriptions Request URL (core/messaging/):
+// a reply in the thread under an approval request or a question, which
+// the agent answers about that request. Outside the admin login like the
+// button endpoint above, and verified with the same signing secret.
+// Slack's URL check is answered before that, since the app is created
+// before its signing secret can be saved here; it only echoes Slack's
+// own challenge back.
+async function handleSlackEvents(req: IncomingMessage, res: ServerResponse, agentName: string): Promise<void> {
+  const rawBody = await readRawBody(req)
+  const entry = getEntry(agentName)
+  if (!entry) {
+    res.writeHead(404, { 'content-type': 'text/plain' }).end('No such agent.')
+    return
+  }
+  const event = parseSlackEvent(rawBody)
+  if (event.type === 'url_verification') {
+    res.writeHead(200, { 'content-type': 'application/json' }).end(JSON.stringify({ challenge: event.challenge }))
+    return
+  }
+  const { botToken, signingSecret } = slackCredentialsFor(entry.config)
+  if (!signingSecret || !botToken) {
+    res.writeHead(404, { 'content-type': 'text/plain' }).end('No Slack bot token and signing secret are set for this agent.')
+    return
+  }
+  const timestamp = req.headers['x-slack-request-timestamp']
+  const signature = req.headers['x-slack-signature']
+  if (!verifySlackRequest(rawBody, typeof timestamp === 'string' ? timestamp : undefined, typeof signature === 'string' ? signature : undefined, signingSecret)) {
+    res.writeHead(401, { 'content-type': 'text/plain' }).end('Invalid Slack signature.')
+    return
+  }
+  // Slack wants an answer within three seconds; the reply is posted after.
+  res.writeHead(200).end()
+  if (event.type !== 'message' || !firstSighting(event)) return
+  const environment = process.env.LOOPENGINE_ENV ?? 'production'
+  await handleInboundMessage(event, {
+    agentName,
+    agentDir: agentDirFor(entry.config),
+    systemPrompt: entry.config.systemPrompt,
+    connector: createSlackConnector(botToken),
+    createModelCall: () => entry.createModelCall(),
+    getCheckpoint: (pendingId) => checkpoints.get(pendingId),
+    getHistory: (checkpoint) => sessions.getHistory(`${checkpoint.tenant}:${environment}:${checkpoint.agent}:${checkpoint.sessionId}`),
+    plan: process.env.LOOPENGINE_PLAN,
+  })
+}
+
 // Set once shutdown() starts, so /healthz turns 503 while the server
 // drains and a router or load balancer stops sending it new requests.
 let shuttingDown = false
@@ -2719,10 +2786,23 @@ const server = createServer(async (req, res) => {
     return
   }
 
+  const slackEventsMatch = req.method === 'POST' && (req.url ?? '/').split('?')[0].match(/^\/hooks\/slack\/([^/]+)\/events$/)
+  if (slackEventsMatch) {
+    try {
+      lastRequestAt = Date.now()
+      await tracked(() => handleSlackEvents(req, res, decodeURIComponent(slackEventsMatch[1])))
+    } catch (err) {
+      console.error('[loopengine] Slack event failed:', err)
+      if (!res.headersSent) res.writeHead(500).end()
+    }
+    return
+  }
+
   const slackHookMatch = req.method === 'POST' && (req.url ?? '/').split('?')[0].match(/^\/hooks\/slack\/([^/]+)$/)
   if (slackHookMatch) {
     try {
-      await handleSlackInteraction(req, res, decodeURIComponent(slackHookMatch[1]))
+      lastRequestAt = Date.now()
+      await tracked(() => handleSlackInteraction(req, res, decodeURIComponent(slackHookMatch[1])))
     } catch (err) {
       console.error('[loopengine] Slack interaction failed:', err)
       if (!res.headersSent) res.writeHead(500).end()
@@ -2733,7 +2813,8 @@ const server = createServer(async (req, res) => {
   const decideMatch = (req.method === 'GET' || req.method === 'POST') && (req.url ?? '/').split('?')[0].match(/^\/decide\/([A-Za-z0-9_.-]+)$/)
   if (decideMatch) {
     try {
-      await handleDecide(req, res, decideMatch[1])
+      lastRequestAt = Date.now()
+      await tracked(() => handleDecide(req, res, decideMatch[1]))
     } catch (err) {
       console.error('[loopengine] decision link failed:', err)
       if (!res.headersSent) res.writeHead(500, { 'content-type': 'application/json' }).end(JSON.stringify({ error: 'Something went wrong; try again.' }))

package/template/package.json

@@ -9,7 +9,7 @@
     "cli": "tsx adapters/cli.ts"
   },
   "dependencies": {
-    "loopengine": "^0.1.77",
+    "loopengine": "^0.1.79",
     "actauth": "^0.0.12",
     "tsx": "^4.19.0",
     "typescript": "^5.7.0"