create-loopengine 0.1.67 → 0.1.69

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-loopengine",
-  "version": "0.1.67",
+  "version": "0.1.69",
   "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/adapters/http.ts

@@ -132,6 +132,10 @@ import {
   replyPrivatelyInSlack,
   type MessagingDecision,
   type DecisionOutcome,
+  type MessagingDeps,
+  handleMessagingAction,
+  agentConfirmTools,
+  setAgentConfirmTools,
   openSlackAnswerModal,
   parseSlackInteraction,
   replyInSlack,
@@ -1287,6 +1291,28 @@ async function handleApproversPut(req: IncomingMessage, res: ServerResponse, age
   }
 }
 
+// Messaging tab → Confirm-required tools: tools whose approval by reply
+// needs a Confirm click. Admin login needed, like the approvers.
+async function handleConfirmToolsPut(req: IncomingMessage, res: ServerResponse, agentName: string): Promise<void> {
+  const entry = getEntry(agentName)
+  if (!entry) {
+    res.writeHead(404, { 'content-type': 'application/json' }).end(JSON.stringify({ error: `unknown agent '${agentName}'` }))
+    return
+  }
+  if (!secretsProtected) {
+    res.writeHead(403, { 'content-type': 'application/json' }).end(JSON.stringify({ error: 'Changing Confirm-required tools needs LOOPENGINE_ADMIN_AUTH set on the server.' }))
+    return
+  }
+  const body = await readJsonBody(req)
+  try {
+    const tools = setAgentConfirmTools(entry.config, body.tools)
+    res.writeHead(200, { 'content-type': 'application/json' }).end(JSON.stringify({ tools }))
+  } catch (err) {
+    const status = err instanceof NotifierFileError ? 400 : 500
+    res.writeHead(status, { 'content-type': 'application/json' }).end(JSON.stringify({ error: err instanceof Error ? err.message : String(err) }))
+  }
+}
+
 async function handleSlackMembers(res: ServerResponse, agentName: string): Promise<void> {
   const entry = getEntry(agentName)
   if (!entry) {
@@ -2290,7 +2316,12 @@ async function resolvePendingApproval(res: ServerResponse, pendingId: string, bo
             sessionId: checkpoint.sessionId,
             env: createAgentEnv(entry.config.name, agentDirFor(entry.config)),
           })
-          resultBlock = { type: 'tool_result', tool_use_id: item.toolUseId, content: JSON.stringify(output), is_error: false }
+          // The agent's own history still shows the arguments it asked
+          // for, so say when the approver changed them; otherwise its
+          // reply describes what it asked for, not what ran.
+          const changed = editedArgs && JSON.stringify(editedArgs) !== JSON.stringify(item.args)
+          const content = changed ? `The approver changed the arguments before it ran: ${JSON.stringify(editedArgs)}. Result: ${JSON.stringify(output)}` : JSON.stringify(output)
+          resultBlock = { type: 'tool_result', tool_use_id: item.toolUseId, content, is_error: false }
         } catch (err) {
           resultBlock = { type: 'tool_result', tool_use_id: item.toolUseId, content: `ERROR: ${err}`, is_error: true }
         }
@@ -2773,23 +2804,39 @@ async function handleSlackInteraction(req: IncomingMessage, res: ServerResponse,
   res.writeHead(200).end()
   if (interaction.type === 'ignore') return
 
+  // A button under one of the agent's own thread replies: Approve as
+  // changed, Keep original, Confirm, Cancel (core/messaging/engine.ts).
+  if (interaction.type === 'action') {
+    if (!botToken) return
+    const text = await handleMessagingAction(interaction.action, interaction.pendingId, interaction.user ?? '', slackMessagingDeps(agentName, entry, botToken))
+    if (interaction.responseUrl) await replyInSlack(interaction.responseUrl, text).catch((err) => console.error('[loopengine] Slack reply failed:', err))
+    return
+  }
+
+  // Approve reports what ran, so the final arguments are in the channel.
+  let ran = ''
+  if (interaction.type === 'decide' && interaction.decision === 'approve') {
+    const item = (await checkpoints.get(interaction.pendingId))?.outstanding[interaction.pendingId]
+    if (item) ran = `\nRan \`${item.tool}\` with \`${JSON.stringify(item.args)}\`.`
+  }
   const capture = captureResponse()
   if (interaction.type === 'decide') await resolvePendingApproval(capture.res, interaction.pendingId, { decision: interaction.decision })
   else await answerPendingQuestion(capture.res, interaction.pendingId, { answer: interaction.answer })
   const outcome = await capture.done
   if (interaction.responseUrl) {
-    const text = slackOutcomeText(interaction.type === 'decide' ? interaction.decision : 'answer', outcome.status, outcome.body, interaction.user)
+    let text = slackOutcomeText(interaction.type === 'decide' ? interaction.decision : 'answer', outcome.status, outcome.body, interaction.user)
+    if (ran && outcome.status < 400 && !outcome.body.alreadyResolved) text += ran
     await replyInSlack(interaction.responseUrl, text).catch((err) => console.error('[loopengine] Slack reply failed:', err))
   }
 }
 
 // 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.
+// the agent answers about that request, and which an approver can use to
+// decide or change it. 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)
@@ -2816,8 +2863,14 @@ async function handleSlackEvents(req: IncomingMessage, res: ServerResponse, agen
   // Slack wants an answer within three seconds; the reply is posted after.
   res.writeHead(200).end()
   if (event.type !== 'message' || !firstSighting(event) || !slackConversationsOn(entry.config)) return
+  await handleInboundMessage(event, slackMessagingDeps(agentName, entry, botToken))
+}
+
+// What core/messaging/ needs from this server to answer, decide and
+// change an agent's Slack requests.
+function slackMessagingDeps(agentName: string, entry: RegistryEntry, botToken: string): MessagingDeps {
   const environment = process.env.LOOPENGINE_ENV ?? 'production'
-  await handleInboundMessage(event, {
+  return {
     agentName,
     agentDir: agentDirFor(entry.config),
     systemPrompt: entry.config.systemPrompt,
@@ -2827,8 +2880,24 @@ async function handleSlackEvents(req: IncomingMessage, res: ServerResponse, agen
     getHistory: (checkpoint) => sessions.getHistory(`${checkpoint.tenant}:${environment}:${checkpoint.agent}:${checkpoint.sessionId}`),
     plan: process.env.LOOPENGINE_PLAN,
     approvers: () => agentApprovers(entry.config),
+    confirmTools: () => agentConfirmTools(entry.config),
     decide: decideFromMessaging,
-  })
+    toolSchema: async (toolName) => (await resolveAgentTool(entry.config, toolName))?.input_schema,
+    // The same checks the console's approve-with-edits applies, plus the
+    // permission rules: changed arguments a rule denies are refused.
+    checkArgs: async (pendingId, args) => {
+      const checkpoint = await checkpoints.get(pendingId)
+      const item = checkpoint?.outstanding[pendingId]
+      if (!checkpoint || !item) return 'the request was already decided'
+      const tool = await resolveAgentTool(entry.config, item.tool)
+      if (!tool) return `the tool '${item.tool}' no longer exists`
+      const invalid = validateEditedArgs(args, tool.input_schema)
+      if (invalid) return `the arguments ${invalid}`
+      const [decision, rule] = loadRules(entry.config).resolve(item.tool, args, { tenant: checkpoint.tenant, environment, agent: checkpoint.agent })
+      if (decision === 'deny') return `a permission rule${rule?.name ? ` (${rule.name})` : ''} doesn't allow it`
+      return undefined
+    },
+  }
 }
 
 // A decision made by replying in a request's thread (core/messaging/),
@@ -2837,7 +2906,7 @@ async function handleSlackEvents(req: IncomingMessage, res: ServerResponse, agen
 async function decideFromMessaging(pendingId: string, decision: MessagingDecision): Promise<DecisionOutcome> {
   const capture = captureResponse()
   if (decision.kind === 'answer') await answerPendingQuestion(capture.res, pendingId, { answer: decision.answer })
-  else await resolvePendingApproval(capture.res, pendingId, { decision: decision.kind })
+  else await resolvePendingApproval(capture.res, pendingId, { decision: decision.kind, ...(decision.kind === 'approve' && decision.editedArgs ? { editedArgs: decision.editedArgs } : {}) })
   const { status, body } = await capture.done
   if (status >= 400) return { error: typeof body.error === 'string' ? body.error : `HTTP ${status}` }
   if (body.alreadyResolved) return { alreadyResolved: true }
@@ -3405,6 +3474,11 @@ const server = createServer(async (req, res) => {
       await handleApproversPut(req, res, decodeURIComponent(approversMatch[1]))
       return
     }
+    const confirmToolsMatch = req.method === 'PUT' && pathname.match(/^\/agents\/([^/]+)\/notifier\/confirm-tools$/)
+    if (confirmToolsMatch) {
+      await handleConfirmToolsPut(req, res, decodeURIComponent(confirmToolsMatch[1]))
+      return
+    }
     const slackMembersMatch = req.method === 'GET' && pathname.match(/^\/agents\/([^/]+)\/notifier\/slack-members$/)
     if (slackMembersMatch) {
       await handleSlackMembers(res, decodeURIComponent(slackMembersMatch[1]))

package/template/package.json

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