loopengine 0.1.87 → 0.1.89

package/dist/core/messaging/connector.d.ts

@@ -48,8 +48,8 @@ export interface MessagingConnector {
     /** The thread's messages, oldest first, its first message included. */
     fetchThread(conversation: string, threadTs: string): Promise<ThreadMessage[]>;
     postInThread(conversation: string, threadTs: string, text: string): Promise<void>;
-    /** A thread reply with buttons. */
-    postChoice(conversation: string, threadTs: string, text: string, choices: MessagingChoice[]): Promise<void>;
+    /** A thread reply with buttons; resolves with the new message's id. */
+    postChoice(conversation: string, threadTs: string, text: string, choices: MessagingChoice[]): Promise<string | undefined>;
     /** Replaces the request message itself (and its buttons) with the
      * outcome, so nobody acts on a decision already made. Optional. */
     replaceMessage?(conversation: string, ts: string, text: string): Promise<void>;

package/dist/core/messaging/connectors/slack/events.js

@@ -77,6 +77,7 @@ export function createSlackConnector(botToken) {
             const body = (await res.json());
             if (!body.ok)
                 console.error('[loopengine] chat.postMessage (choice) failed:', body.error);
+            return body.ok ? body.ts : undefined;
         },
         async replaceMessage(conversation, ts, text) {
             const mrkdwn = toSlackMrkdwn(text);

package/dist/core/messaging/decide.d.ts

@@ -15,9 +15,14 @@ export type ReplyDecision = {
 } | {
     decision: 'continue';
 };
-export type DecisionRequest = {
+export type DecisionRequest = 
+/** `changeShown`: the person was just shown a proposed change to the
+ * arguments, waiting for their approval (our own fixed fact, not text
+ * anyone else wrote). */
+{
     kind: 'approval';
     tool: string;
+    changeShown?: boolean;
 } | {
     kind: 'question';
     question: string;

package/dist/core/messaging/decide.js

@@ -18,7 +18,7 @@ function recordTool(kind) {
 }
 export function decisionPrompt(request) {
     const about = request.kind === 'approval'
-        ? `An AI agent is waiting for approval to run the tool \`${request.tool}\`.`
+        ? `An AI agent is waiting for approval to run the tool \`${request.tool}\`.${request.changeShown ? ' The person was just shown a proposed change to its arguments, waiting for their approval: a plain yes or ok approves that change.' : ''}`
         : `An AI agent asked this question and is waiting for the answer: ${JSON.stringify(request.question)}${request.options?.length ? `\nOptions it offered: ${request.options.map((o) => JSON.stringify(o)).join(', ')}` : ''}`;
     const rules = request.kind === 'approval'
         ? [

package/dist/core/messaging/engine.d.ts

@@ -60,6 +60,9 @@ export declare function handleInboundMessage(message: InboundMessage, deps: Mess
  * (full-width ones too) ignored, then compared with the fixed list. A
  * trailing question mark keeps it from matching ("yes?"). */
 export declare function isPlainApproval(text: string): boolean;
+/** For a decision made outside the thread (the request's own buttons):
+ * replaces the thread's message with buttons, if any, with `text`. */
+export declare function settleThreadChoice(deps: MessagingDeps, pendingId: string, text: string): Promise<void>;
 /** A click on one of the engine's own buttons (Approve as changed, Keep
  * original, Confirm, Cancel) — the caller has already checked the
  * person may decide. Returns what the clicked message should now say. */

package/dist/core/messaging/engine.js

@@ -54,7 +54,7 @@ export async function handleInboundMessage(message, deps) {
         }
         const modelCall = deps.createModelCall();
         const request = link.kind === 'approval'
-            ? { kind: 'approval', tool: item.tool }
+            ? { kind: 'approval', tool: item.tool, changeShown: Boolean(link.proposedArgs) }
             : {
                 kind: 'question',
                 question: typeof item.args.question === 'string' ? item.args.question : JSON.stringify(item.args),
@@ -84,8 +84,7 @@ export async function handleInboundMessage(message, deps) {
                     await say(`I can't change it that way: ${problem}. The request is unchanged.`);
                     return;
                 }
-                recordThread(deps.agentDir, { ...link, proposedArgs: proposed });
-                await connector.postChoice(message.conversation, threadTs, `Here's the change ${who} asked for:\n${formatChange(item.args, proposed, connector.escape, await deps.toolSchema(item.tool))}\nNothing else changes.`, [
+                await postChoice(deps, { ...link, proposedArgs: proposed }, `Here's the change ${who} asked for:\n${formatChange(item.args, proposed, connector.escape, await deps.toolSchema(item.tool))}\nNothing else changes.`, [
                     { action: 'approve_edited', label: 'Approve as changed', style: 'primary', pendingId: link.pendingId },
                     { action: 'keep_original', label: 'Keep original', pendingId: link.pendingId },
                     { action: 'deny', label: 'Deny', style: 'danger', pendingId: link.pendingId },
@@ -100,7 +99,7 @@ export async function handleInboundMessage(message, deps) {
                     await runApproved(deps, link, item.tool, args, who);
                     return;
                 }
-                await connector.postChoice(message.conversation, threadTs, `Confirm to run \`${item.tool}\` with:\n${formatArgs(args, connector.escape, await deps.toolSchema(item.tool))}`, [
+                await postChoice(deps, link, `Confirm to run \`${item.tool}\` with:\n${formatArgs(args, connector.escape, await deps.toolSchema(item.tool))}`, [
                     { action: 'confirm', label: 'Confirm', style: 'primary', pendingId: link.pendingId },
                     { action: 'cancel_confirm', label: 'Cancel', pendingId: link.pendingId },
                 ]);
@@ -112,6 +111,7 @@ export async function handleInboundMessage(message, deps) {
             if (!outcome.error && !outcome.alreadyResolved) {
                 const what = link.kind === 'approval' ? `\`${item.tool}\`` : 'The question';
                 await replaceRequest(connector, link, `${what} was ${verdict.decision === 'deny' ? 'denied' : `answered ("${answer}")`} by ${who} in the thread.`);
+                await settleChoice(deps, link, verdict.decision === 'deny' ? `Denied by ${who}.` : `Answered by ${who}.`);
             }
             return;
         }
@@ -200,10 +200,35 @@ async function runApproved(deps, link, tool, args, who) {
     await connector.postInThread(link.conversation, link.ts, `Approved${edited ? ' as changed' : ''} by ${who}. Running \`${tool}\` with:\n${formatArgs(args, connector.escape, await deps.toolSchema(tool))}`);
     const outcome = await deps.decide(link.pendingId, { kind: 'approve', ...(edited ? { editedArgs: args } : {}) });
     await connector.postInThread(link.conversation, link.ts, outcomeText('approve', who, outcome));
-    if (!outcome.error && !outcome.alreadyResolved)
+    if (!outcome.error && !outcome.alreadyResolved) {
         await replaceRequest(connector, link, `\`${tool}\` was approved${edited ? ' as changed' : ''} by ${who} in the thread.`);
+        await settleChoice(deps, link, `Approved${edited ? ' as changed' : ''} by ${who}.`);
+    }
     return outcome;
 }
+/** Posts a message with buttons and remembers it, replacing the previous
+ * one (whose buttons no longer apply). `link` carries any other change
+ * to record with it, such as a proposed change. */
+async function postChoice(deps, link, text, choices) {
+    await settleChoice(deps, link, 'Replaced by the message below.');
+    const choiceTs = await deps.connector.postChoice(link.conversation, link.ts, text, choices);
+    recordThread(deps.agentDir, { ...link, choiceTs });
+}
+/** Replaces the thread's message with buttons, if there is one, so its
+ * buttons don't linger after the request is decided. */
+async function settleChoice(deps, link, text) {
+    if (!link.choiceTs || !deps.connector.replaceMessage)
+        return;
+    await deps.connector.replaceMessage(link.conversation, link.choiceTs, text).catch((err) => console.error('[loopengine] could not update a message with buttons:', err));
+    recordThread(deps.agentDir, { ...link, choiceTs: undefined });
+}
+/** For a decision made outside the thread (the request's own buttons):
+ * replaces the thread's message with buttons, if any, with `text`. */
+export async function settleThreadChoice(deps, pendingId, text) {
+    const link = findThreadByPending(deps.agentDir, pendingId);
+    if (link)
+        await settleChoice(deps, link, text);
+}
 async function replaceRequest(connector, link, text) {
     if (!connector.replaceMessage)
         return;
@@ -222,15 +247,19 @@ export async function handleMessagingAction(action, pendingId, user, deps) {
         if (!item)
             return 'This request has already been decided.';
         const who = deps.connector.mention(user);
+        // The clicked message is the one with buttons; the caller replaces it
+        // with what this returns, so it's no longer tracked.
         if (action === 'keep_original') {
-            recordThread(deps.agentDir, { ...link, proposedArgs: undefined });
+            recordThread(deps.agentDir, { ...link, proposedArgs: undefined, choiceTs: undefined });
             return `${who} kept the original request. It's still waiting for a decision.`;
         }
-        if (action === 'cancel_confirm')
+        if (action === 'cancel_confirm') {
+            recordThread(deps.agentDir, { ...link, choiceTs: undefined });
             return `${who} cancelled. Nothing ran; the request is still waiting for a decision.`;
+        }
         if (action === 'approve_edited' && !link.proposedArgs)
             return 'That change was dropped, so there is nothing to approve as changed.';
-        const outcome = await runApproved(deps, link, item.tool, link.proposedArgs ?? item.args, who);
+        const outcome = await runApproved(deps, { ...link, choiceTs: undefined }, item.tool, link.proposedArgs ?? item.args, who);
         if (outcome.alreadyResolved)
             return 'This request has already been decided.';
         return action === 'confirm' ? `Confirmed by ${who}.` : `Approved as changed by ${who}.`;

package/dist/core/messaging/threads.d.ts

@@ -10,6 +10,10 @@ export interface ThreadLink {
     /** A change an approver asked for, waiting to be approved as changed.
      * Recording the thread again without it drops the change. */
     proposedArgs?: Record<string, unknown>;
+    /** The latest message the agent posted with buttons in this thread (a
+     * proposed change, a Confirm), so it can be replaced once the request
+     * is decided and its buttons don't linger. */
+    choiceTs?: string;
 }
 /** Appends one request's thread. Never throws: a request that can't be
  * mapped still works through its buttons and link. */

package/dist/core/messaging/threads.js

@@ -12,8 +12,8 @@ function threadsFile(agentDir) {
 export function recordThread(agentDir, link) {
     try {
         mkdirSync(join(agentDir, '.messaging'), { recursive: true });
-        const { app, conversation, ts, pendingId, kind, proposedArgs } = link;
-        appendFileSync(threadsFile(agentDir), JSON.stringify({ app, conversation, ts, pendingId, kind, ...(proposedArgs ? { proposedArgs } : {}), at: new Date().toISOString() }) + '\n');
+        const { app, conversation, ts, pendingId, kind, proposedArgs, choiceTs } = link;
+        appendFileSync(threadsFile(agentDir), JSON.stringify({ app, conversation, ts, pendingId, kind, ...(proposedArgs ? { proposedArgs } : {}), ...(choiceTs ? { choiceTs } : {}), at: new Date().toISOString() }) + '\n');
     }
     catch (err) {
         console.error('[loopengine] could not record the thread:', err instanceof Error ? err.message : err);

package/dist/index.d.ts

@@ -12,7 +12,7 @@ export { listDeliveries, recordDelivery, type NotifierDelivery } from '#core/not
 export { describeNotifier } from '#core/http-notifier.js';
 export { Scheduler, ScheduleError, FileSchedulerStore, getSchedulerStore, setSchedulerStore, createScheduledTask, listScheduledTasks, getScheduledTask, cancelScheduledTask, pauseScheduledTask, resumeScheduledTask, runScheduledTaskNow, deleteScheduledTask, nextScheduledWakeAt, importLegacyScheduledTasks, parseEvery, describeSchedule, type ScheduledTask, type ScheduledTaskRun, type ScheduledTaskStatus, type Schedule, type SchedulerStore, type FireTask, type CreateScheduledTaskInput } from '#core/scheduler.js';
 export { NOTIFIER_SLACK_SIGNING_SECRET_VAR } from '#core/notifier-file.js';
-export { firstSighting, handleInboundMessage, handleMessagingAction, isPlainApproval, type MessagingDeps, type MessagingDecision, type DecisionOutcome } from '#core/messaging/engine.js';
+export { firstSighting, handleInboundMessage, handleMessagingAction, settleThreadChoice, isPlainApproval, type MessagingDeps, type MessagingDecision, type DecisionOutcome } from '#core/messaging/engine.js';
 export { formatArgs, formatChange, labelFor } from '#core/messaging/format-args.js';
 export { decideReply, proposeEdit, describeChange, type ReplyDecision, type DecisionRequest } from '#core/messaging/decide.js';
 export { recordThread, findThread, findThreadByPending, type ThreadLink } from '#core/messaging/threads.js';

package/dist/index.js

@@ -14,7 +14,7 @@ export { listDeliveries, recordDelivery } from '#core/notifier-deliveries.js';
 export { describeNotifier } from '#core/http-notifier.js';
 export { Scheduler, ScheduleError, FileSchedulerStore, getSchedulerStore, setSchedulerStore, createScheduledTask, listScheduledTasks, getScheduledTask, cancelScheduledTask, pauseScheduledTask, resumeScheduledTask, runScheduledTaskNow, deleteScheduledTask, nextScheduledWakeAt, importLegacyScheduledTasks, parseEvery, describeSchedule } from '#core/scheduler.js';
 export { NOTIFIER_SLACK_SIGNING_SECRET_VAR } from '#core/notifier-file.js';
-export { firstSighting, handleInboundMessage, handleMessagingAction, isPlainApproval } from '#core/messaging/engine.js';
+export { firstSighting, handleInboundMessage, handleMessagingAction, settleThreadChoice, isPlainApproval } from '#core/messaging/engine.js';
 export { formatArgs, formatChange, labelFor } from '#core/messaging/format-args.js';
 export { decideReply, proposeEdit, describeChange } from '#core/messaging/decide.js';
 export { recordThread, findThread, findThreadByPending } from '#core/messaging/threads.js';

package/dist/web/global-config-page.js

@@ -327,15 +327,23 @@ ${consoleShellScript}
       box.innerHTML = '<p class="hint">' + escapeHtml(u.unavailableReason) + '</p>' + (u.templateVersion ? upgradeCheckedLine(u) : '');
     } else if (!u.updateAvailable) {
       box.innerHTML = '<p>You' + String.fromCharCode(8217) + 're on the latest version, <code>' + escapeHtml(u.current) + '</code>.</p>' + upgradeCheckedLine(u);
-    } else if (u.unavailableReason) {
-      box.innerHTML = '<p>LoopEngine <code>' + escapeHtml(u.latest) + '</code> is available (this server runs <code>' + escapeHtml(u.current) + '</code>).</p><p class="hint">' + escapeHtml(u.unavailableReason) + '</p>';
-    } else if (!u.canUpgrade) {
-      box.innerHTML = '<p>LoopEngine <code>' + escapeHtml(u.latest) + '</code> is available (this server runs <code>' + escapeHtml(u.current) + '</code>).</p><p class="hint">Set LOOPENGINE_ADMIN_AUTH to upgrade from here, or run <code>npx create-loopengine@latest upgrade</code>.</p>';
     } else {
-      box.innerHTML = '<p>LoopEngine <code>' + escapeHtml(u.latest) + '</code> is available (this server runs <code>' + escapeHtml(u.current) + '</code>).</p>' +
-        '<p class="hint">' + UPGRADE_NOTE + (u.restartsItself ? '' : ' This server has nothing to restart it, so restart it yourself afterwards.') + '</p>' +
-        '<p><button type="button" class="primary" id="upgradeBtn">Upgrade to ' + escapeHtml(u.latest) + '</button></p>' +
-        '<div id="upgradeMsg" class="hint"></div>';
+      // Only the template behind (a fix in adapters/http.ts and the like,
+      // with loopengine already current) is offered too.
+      var headline = u.templateUpdateAvailable
+        ? '<p>A template update is available: <code>' + escapeHtml(u.latestTemplate) + '</code> (this project' + String.fromCharCode(8217) + 's template is <code>' + escapeHtml(u.templateVersion) + '</code>). LoopEngine stays at <code>' + escapeHtml(u.current) + '</code>.</p>'
+        : '<p>LoopEngine <code>' + escapeHtml(u.latest) + '</code> is available (this server runs <code>' + escapeHtml(u.current) + '</code>).</p>';
+      var label = u.templateUpdateAvailable ? 'Update the template to ' + escapeHtml(u.latestTemplate) : 'Upgrade to ' + escapeHtml(u.latest);
+      if (u.unavailableReason) {
+        box.innerHTML = headline + '<p class="hint">' + escapeHtml(u.unavailableReason) + '</p>';
+      } else if (!u.canUpgrade) {
+        box.innerHTML = headline + '<p class="hint">Set LOOPENGINE_ADMIN_AUTH to upgrade from here, or run <code>npx create-loopengine@latest upgrade</code>.</p>';
+      } else {
+        box.innerHTML = headline +
+          '<p class="hint">' + UPGRADE_NOTE + (u.restartsItself ? '' : ' This server has nothing to restart it, so restart it yourself afterwards.') + '</p>' +
+          '<p><button type="button" class="primary" id="upgradeBtn">' + label + '</button></p>' +
+          '<div id="upgradeMsg" class="hint"></div>';
+      }
     }
   }
 
@@ -357,14 +365,16 @@ ${consoleShellScript}
   }
 
   // After a successful upgrade the server restarts: wait for it to answer
-  // again on the new version, then reload so the page runs the new code.
+  // again on the new versions (loopengine, and the template's), then
+  // reload so the page runs the new code.
   function waitForRestart(target, tries) {
     if (tries > 90) { upgradeMsg('The server hasn' + String.fromCharCode(8217) + 't come back yet. Reload this page in a minute.', true); return; }
     setTimeout(function () {
-      fetch('/config/settings', { cache: 'no-store' })
+      fetch('/config/upgrade', { cache: 'no-store' })
         .then(function (r) { return r.ok ? r.json() : null; })
-        .then(function (s) {
-          if (s && s.version === target) location.reload();
+        .then(function (u) {
+          var ready = u && !u.running && (!target.version || u.current === target.version) && (!target.template || u.templateVersion === target.template);
+          if (ready && tries > 0) location.reload();
           else waitForRestart(target, tries + 1);
         })
         .catch(function () { waitForRestart(target, tries + 1); });
@@ -398,14 +408,15 @@ ${consoleShellScript}
         var changed = o.files.filter(function (f) { return f.status === 'updated'; }).map(function (f) { return f.file; });
         var kept = o.files.filter(function (f) { return f.status === 'kept'; }).map(function (f) { return f.file; });
         var deps = o.dependencies.map(function (d) { return d.name + ' ' + d.from + ' ' + String.fromCharCode(8594) + ' ' + d.to; });
-        var target = (o.dependencies.filter(function (d) { return d.name === 'loopengine'; })[0] || {}).to;
+        var loopengineTo = (o.dependencies.filter(function (d) { return d.name === 'loopengine'; })[0] || {}).to;
+        var target = { version: loopengineTo ? loopengineTo.replace(/[^0-9.]/g, '') : null, template: o.toVersion || null };
         var summary = (deps.length ? 'Installed ' + escapeHtml(deps.join(', ')) + '. ' : '') +
           (changed.length ? 'Updated ' + escapeHtml(changed.join(', ')) + '. ' : '') +
           (kept.length ? 'Left as you edited them: ' + escapeHtml(kept.join(', ')) + '. ' : '');
         btn.textContent = 'Upgraded';
-        if (r.body.restarting && target) {
+        if (r.body.restarting && (target.version || target.template)) {
           upgradeMsg(summary + 'Restarting' + String.fromCharCode(8230), false);
-          waitForRestart(target.replace(/[^0-9.]/g, ''), 0);
+          waitForRestart(target, 0);
         } else {
           upgradeMsg(summary + 'Restart the server to finish.', false);
         }

package/dist/web/upgrade-admin.d.ts

@@ -6,11 +6,17 @@ export interface UpgradeStatus {
     latest: string | null;
     /** When npm was last asked for `latest`. */
     checkedAt: string | null;
+    /** A newer loopengine, or a newer template, or both. */
     updateAvailable: boolean;
     /** The create-loopengine version this project was scaffolded or last
      * upgraded from (.create-loopengine.json); null when the project
      * wasn't made by create-loopengine, which the button can't upgrade. */
     templateVersion: string | null;
+    /** Latest create-loopengine on npm; null when npm couldn't be reached. */
+    latestTemplate: string | null;
+    /** Only the template is behind: a fix in adapters/http.ts and the
+     * other template files, with loopengine already current. */
+    templateUpdateAvailable: boolean;
     /** Why the button is off, when it is. */
     unavailableReason?: string;
     running: boolean;

package/dist/web/upgrade-admin.js

@@ -43,18 +43,24 @@ export function setUpgradeRunner(next) {
 // A minute, so reloading Settings doesn't ask npm every time while a
 // release that just came out shows up soon (the page's Check again skips it).
 let latestCache;
-async function latestLoopengine(projectDir) {
-    if (latestCache && latestCache.until > Date.now())
-        return latestCache.value;
-    let value = null;
+async function npmLatest(name, projectDir) {
     try {
-        value = (await run('npm', ['view', 'loopengine', 'version'], projectDir, 15_000)).trim() || null;
+        return (await run('npm', ['view', name, 'version'], projectDir, 15_000)).trim() || null;
     }
     catch {
-        value = null;
+        return null;
     }
-    latestCache = { value, until: Date.now() + 60_000, at: new Date().toISOString() };
-    return value;
+}
+/** The latest loopengine and create-loopengine on npm, asked together. */
+async function latestVersions(projectDir) {
+    if (latestCache && latestCache.until > Date.now())
+        return latestCache;
+    const [value, template] = await Promise.all([npmLatest('loopengine', projectDir), npmLatest('create-loopengine', projectDir)]);
+    latestCache = { value, template, until: Date.now() + 60_000, at: new Date().toISOString() };
+    return latestCache;
+}
+async function latestLoopengine(projectDir) {
+    return (await latestVersions(projectDir)).value;
 }
 function templateVersion(projectDir) {
     const path = join(projectDir, '.create-loopengine.json');
@@ -73,14 +79,18 @@ export async function describeUpgrade(projectDir = process.cwd(), options = {})
     if (options.refresh)
         latestCache = undefined;
     const current = loopengineVersion();
-    const latest = await latestLoopengine(projectDir);
+    const { value: latest, template: latestTemplate } = await latestVersions(projectDir);
     const template = templateVersion(projectDir);
+    const loopengineBehind = Boolean(latest && semver.valid(current) && semver.gt(latest, current));
+    const templateBehind = Boolean(template && latestTemplate && semver.valid(template) && semver.valid(latestTemplate) && semver.gt(latestTemplate, template));
     const status = {
         current,
         latest,
         checkedAt: latestCache?.at ?? null,
-        updateAvailable: Boolean(latest && semver.valid(current) && semver.gt(latest, current)),
+        updateAvailable: loopengineBehind || templateBehind,
         templateVersion: template,
+        latestTemplate,
+        templateUpdateAvailable: templateBehind && !loopengineBehind,
         running,
     };
     if (!template)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "loopengine",
-  "version": "0.1.87",
+  "version": "0.1.89",
   "type": "module",
   "description": "Runtime for tool-using AI agents with a transparent ReAct loop.",
   "license": "MIT",