@mindstudio-ai/remy 0.1.293 → 0.1.295

package/dist/index.js

@@ -195,12 +195,17 @@ async function* streamChat(params) {
       }
       const isStall = err?.message === "stream_stall";
       const errorMessage = isStall ? "Stream stalled \u2014 no data received for 5 minutes" : `Network error: stream interrupted \u2014 ${err?.message ?? "unknown"}`;
-      log.error(isStall ? "Stream stalled" : "Stream interrupted", {
-        requestId,
-        ...subAgentId && { subAgentId },
-        durationMs: Date.now() - startTime,
-        error: errorMessage
-      });
+      const wasAborted = !isStall && !!signal?.aborted;
+      const logAt = wasAborted ? log.warn : log.error;
+      logAt(
+        wasAborted ? "Request aborted mid-stream" : isStall ? "Stream stalled" : "Stream interrupted",
+        {
+          requestId,
+          ...subAgentId && { subAgentId },
+          durationMs: Date.now() - startTime,
+          error: errorMessage
+        }
+      );
       yield { type: "error", error: errorMessage };
       return;
     }
@@ -867,7 +872,7 @@ var init_presentPublishPlan = __esm({
     presentPublishPlanTool = {
       definition: {
         name: "presentPublishPlan",
-        description: "Present a publish changelog to the user for approval \u2014 the consent gate of the release flow, used when the user has asked to publish (the Publish button or an explicit chat request; the `publishing` skill covers the full sequence). Write a clear markdown summary of what changed since the last deploy. The user will see this in a full-screen view and can approve or dismiss. Call this BEFORE committing or pushing.",
+        description: "Present a publish changelog to the user for approval \u2014 the consent gate of the release flow, used when the user has asked to publish (the Publish button or an explicit chat request; the `publishing` skill covers the full sequence). Write a clear markdown summary of what changed since the last deploy. The user reviews this in the editor area and can approve or dismiss. Call this BEFORE committing or pushing.",
         inputSchema: {
           type: "object",
           properties: {
@@ -1034,7 +1039,7 @@ var init_promptUser = __esm({
     promptUserTool = {
       definition: {
         name: "promptUser",
-        description: 'Ask the user structured questions. Choose type first: "form" for structured intake (5+ questions, takes over screen), "inline" for quick clarifications or confirmations. Blocks until the user responds. Result contains `_dismissed: true` if the user dismisses without answering.',
+        description: 'Ask the user structured questions. Choose type first: "form" for structured intake (5+ questions, opens as a full form in the editor area), "inline" for quick clarifications or confirmations. Blocks until the user responds. Result contains `_dismissed: true` if the user dismisses without answering.',
         inputSchema: {
           type: "object",
           properties: {
@@ -1677,7 +1682,7 @@ var init_sentinel = __esm({
 });
 
 // src/compaction/index.ts
-async function compactConversation(messages, apiConfig, model) {
+async function compactConversation(messages, apiConfig, model, signal) {
   const endIndex = findSafeInsertionPoint(messages);
   const boundary = endIndex > 0 ? messages[endIndex - 1] : null;
   const summaries = [];
@@ -1694,7 +1699,8 @@ async function compactConversation(messages, apiConfig, model) {
         "conversation",
         CONVERSATION_SUMMARY_PROMPT,
         conversationMessages,
-        model
+        model,
+        { signal }
       ).then((text) => {
         if (text) {
           summaries.push({ name: "conversation", text });
@@ -1717,7 +1723,8 @@ async function compactConversation(messages, apiConfig, model) {
           name,
           SUBAGENT_SUMMARY_PROMPT,
           subagentMessages,
-          model
+          model,
+          { signal }
         ).then((text) => {
           if (text) {
             summaries.push({ name, text });
@@ -1733,7 +1740,7 @@ async function compactConversation(messages, apiConfig, model) {
   await Promise.all(tasks);
   if (conversationFailed) {
     throw new Error(
-      "Could not summarize the conversation \u2014 the model did not return a usable summary. History left intact."
+      signal?.aborted ? "Compaction cancelled. History left intact." : "Could not summarize the conversation \u2014 the model did not return a usable summary. History left intact."
     );
   }
   const recent = collectRecentNarrative(conversationMessages);
@@ -1969,7 +1976,10 @@ async function generateSummary(apiConfig, name, compactionPrompt, messagesToSumm
           // A split driven by size gets its children a retry of their own. A
           // split that IS the retry does not, or a model that will not
           // summarize at any size fans out call after call before giving up.
-          { allowRetry: opts.forceChunk ? false : allowRetry }
+          {
+            allowRetry: opts.forceChunk ? false : allowRetry,
+            ...opts.signal && { signal: opts.signal }
+          }
         )
       )
     );
@@ -1992,7 +2002,8 @@ async function generateSummary(apiConfig, name, compactionPrompt, messagesToSumm
     name,
     compactionPrompt,
     serialized,
-    model
+    model,
+    opts.signal
   );
   if (summaryText === null) {
     return null;
@@ -2020,7 +2031,7 @@ async function generateSummary(apiConfig, name, compactionPrompt, messagesToSumm
     { forceChunk: true, allowRetry: false }
   );
 }
-async function runSummaryCall(apiConfig, name, compactionPrompt, serialized, model) {
+async function runSummaryCall(apiConfig, name, compactionPrompt, serialized, model, signal) {
   const userContent = `Conversation to summarize:
 
 ${serialized}
@@ -2042,7 +2053,8 @@ Write the summary of the conversation above, following your instructions.`;
     // Each summary call carries a unique 100-200KB chunk that is never
     // re-read (parallel siblings can't read each other's in-flight writes
     // either) — a cache write here is pure waste.
-    cachePolicy: "oneshot"
+    cachePolicy: "oneshot",
+    ...signal && { signal }
   })) {
     if (event.type === "text") {
       summaryText += event.text;
@@ -2066,7 +2078,11 @@ Write the summary of the conversation above, following your instructions.`;
     }
   }
   if (!summaryText.trim()) {
-    log2.warn("Empty summary generated", { name });
+    if (signal?.aborted) {
+      log2.info("Summary cancelled", { name });
+    } else {
+      log2.warn("Empty summary generated", { name });
+    }
     return null;
   }
   return summaryText.trim();
@@ -2861,6 +2877,14 @@ var init_session = __esm({
 function getInflightCompaction() {
   return inflightCompaction;
 }
+function cancelInflightCompaction() {
+  if (!inflightCompaction || !inflightAbort) {
+    return false;
+  }
+  log4.info("Cancelling in-flight compaction");
+  inflightAbort.abort();
+  return true;
+}
 function summariesOf(result) {
   const out = [];
   for (const msg of result.checkpoints) {
@@ -2927,10 +2951,13 @@ function triggerCompaction(state, apiConfig, opts = {}) {
   }
   const { blocking = false, requestId, model, origin, toolCallId } = opts;
   listener?.({ type: "started", blocking, requestId, origin, toolCallId });
+  const abort = new AbortController();
+  inflightAbort = abort;
   inflightCompaction = compactConversation(
     state.messages,
     apiConfig,
-    resolveModel("conversationSummarizer", state.models, model)
+    resolveModel("conversationSummarizer", state.models, model),
+    abort.signal
   ).then((result) => {
     pending = result;
     const summaries = summariesOf(result);
@@ -2942,16 +2969,27 @@ function triggerCompaction(state, apiConfig, opts = {}) {
     log4.info("Compaction complete");
     return summaries;
   }).catch((err) => {
-    const message = err.message || "Compaction failed";
-    listener?.({ type: "complete", error: message, requestId });
-    log4.error("Compaction failed", { error: message });
-    throw err;
+    const cancelled = abort.signal.aborted;
+    const message = cancelled ? "Compaction cancelled" : err.message || "Compaction failed";
+    listener?.({
+      type: "complete",
+      error: message,
+      ...cancelled && { cancelled: true },
+      requestId
+    });
+    if (cancelled) {
+      log4.info("Compaction cancelled");
+    } else {
+      log4.error("Compaction failed", { error: message });
+    }
+    throw cancelled ? new CompactionCancelledError() : err;
   }).finally(() => {
     inflightCompaction = null;
+    inflightAbort = null;
   });
   return inflightCompaction;
 }
-var log4, pending, inflightCompaction, SUMMARY_SECTION_LABELS, listener;
+var log4, CompactionCancelledError, pending, inflightCompaction, inflightAbort, SUMMARY_SECTION_LABELS, listener;
 var init_trigger = __esm({
   "src/compaction/trigger.ts"() {
     "use strict";
@@ -2960,8 +2998,15 @@ var init_trigger = __esm({
     init_surfaces();
     init_session();
     log4 = createLogger("compaction:trigger");
+    CompactionCancelledError = class extends Error {
+      constructor() {
+        super("Compaction cancelled \u2014 no checkpoint was created.");
+        this.name = "CompactionCancelledError";
+      }
+    };
     pending = null;
     inflightCompaction = null;
+    inflightAbort = null;
     SUMMARY_SECTION_LABELS = {
       conversation: "Conversation",
       visualDesignExpert: "Design Agent Thread",
@@ -3018,7 +3063,9 @@ var init_compactConversation = __esm({
           onBackgroundComplete?.(
             toolCallId,
             "compactConversation",
-            `Error: ${err.message || "Compaction failed"}`
+            // A cancel is the user's own doing — report it as an outcome, not as
+            // an error the block renders as a failure.
+            err instanceof CompactionCancelledError ? err.message : `Error: ${err.message || "Compaction failed"}`
           );
         }).finally(() => {
           toolRegistry?.unregister(toolCallId);
@@ -10147,6 +10194,11 @@ var init_stats = __esm({
 });
 
 // src/headless/messageQueue.ts
+function holdRestoredUserItems(items) {
+  return items.map(
+    (item) => item.source === "user" ? { ...item, held: true } : item
+  );
+}
 var MessageQueue;
 var init_messageQueue = __esm({
   "src/headless/messageQueue.ts"() {
@@ -10162,33 +10214,36 @@ var init_messageQueue = __esm({
         this.items.push(item);
         this.onChange?.();
       }
-      shift() {
-        const item = this.items.shift();
+      /**
+       * Index of the first deliverable item, or -1 when there is none.
+       *
+       * Held items are out of the delivery sequence, so the drain skips past them
+       * rather than stopping at them: a message the user parked sits at the head
+       * of the array, and stopping there would strand Remy's own chain steps and
+       * background results queued behind it.
+       */
+      firstDeliverableIndex() {
+        return this.items.findIndex((item) => !item.held);
+      }
+      /** Remove and return the item at `i`; fires onChange. */
+      takeAt(i) {
+        const [item] = this.items.splice(i, 1);
         if (item) {
           this.onChange?.();
         }
         return item;
       }
-      /** Remove and return the first `n` items; fires onChange once. */
-      shiftMany(n) {
-        if (n <= 0) {
+      /** Remove and return `count` items starting at `start`; fires onChange once. */
+      takeRange(start, count) {
+        if (count <= 0) {
           return [];
         }
-        const items = this.items.splice(0, n);
+        const items = this.items.splice(start, count);
         if (items.length > 0) {
           this.onChange?.();
         }
         return items;
       }
-      /** Remove and return all queued items. */
-      drain() {
-        if (this.items.length === 0) {
-          return [];
-        }
-        const all = this.items.splice(0);
-        this.onChange?.();
-        return all;
-      }
       /**
        * Remove all items matching `predicate`. Fires onChange only if something
        * was removed. Returns the removed items.
@@ -10207,6 +10262,49 @@ var init_messageQueue = __esm({
         }
         return removed;
       }
+      /**
+       * Mark matching items `held` — waiting on the user rather than on the agent.
+       * Fires onChange only if something changed. Returns the held items.
+       */
+      holdWhere(predicate) {
+        const held = [];
+        let changed = false;
+        for (const item of this.items) {
+          if (!predicate(item)) {
+            continue;
+          }
+          changed = changed || !item.held;
+          item.held = true;
+          held.push(item);
+        }
+        if (changed) {
+          this.onChange?.();
+        }
+        return held;
+      }
+      /**
+       * Release held items so the normal drain picks them up again — all of them,
+       * or one by command requestId. Fires onChange only if something changed.
+       * Returns the released items.
+       */
+      releaseHeld(id) {
+        const released = [];
+        for (const item of this.items) {
+          if (!item.held || id !== void 0 && item.command.requestId !== id) {
+            continue;
+          }
+          delete item.held;
+          released.push(item);
+        }
+        if (released.length > 0) {
+          this.onChange?.();
+        }
+        return released;
+      }
+      /** Whether anything in the queue will drain on its own (i.e. isn't held). */
+      hasDeliverable() {
+        return this.items.some((item) => !item.held);
+      }
       /**
        * Change a queued item's delivery semantics, keyed by its command
        * requestId. Fires onChange (→ persist + queue_changed) on success.
@@ -10222,14 +10320,35 @@ var init_messageQueue = __esm({
         this.onChange?.();
         return item;
       }
+      /**
+       * Promote an item to ASAP: release any hold, and move it to the head so it
+       * is the next thing delivered. One onChange for all of it.
+       *
+       * Position matters only when no turn is running — mid-turn, ASAP items are
+       * pulled by predicate at the next tool boundary regardless of where they sit
+       * (`takeSteering`), jumping whatever is queued ahead of them. Moving to the
+       * head makes the idle case behave the same way, and matches the card, which
+       * already renders promoted items above everything else.
+       *
+       * Returns the item, or undefined if nothing matches (e.g. it was already
+       * consumed by the running turn).
+       */
+      promoteToFront(id) {
+        const idx = this.items.findIndex((it) => it.command.requestId === id);
+        if (idx === -1) {
+          return void 0;
+        }
+        const [item] = this.items.splice(idx, 1);
+        item.delivery = "asap";
+        delete item.held;
+        this.items.unshift(item);
+        this.onChange?.();
+        return item;
+      }
       /** Copy of current queue contents (for surfacing on events). */
       snapshot() {
         return [...this.items];
       }
-      /** Return the next item without removing it. */
-      peek() {
-        return this.items[0];
-      }
       /** Return the item at index `i` without removing it. */
       peekAt(i) {
         return this.items[i];
@@ -10357,7 +10476,7 @@ var init_headless = __esm({
         });
         await initOrgContext(this.config);
         const resumed = loadSession(this.state);
-        this.queue = new MessageQueue(loadQueue(), () => {
+        this.queue = new MessageQueue(holdRestoredUserItems(loadQueue()), () => {
           this.persistStats();
           this.emit("queue_changed", { queuedMessages: this.queue.snapshot() });
         });
@@ -10410,13 +10529,16 @@ var init_headless = __esm({
               });
             }
           } else {
-            const data = event.error ? { error: event.error } : {};
+            const data = {
+              ...event.error && { error: event.error },
+              ...event.cancelled && { cancelled: true }
+            };
             this.emit("compaction_complete", data, event.requestId);
             if (this.syntheticCompactionId) {
               const id = this.syntheticCompactionId;
               this.syntheticCompactionId = null;
-              const result = event.error ? `Error: ${event.error}` : formatSummariesResult(event.summaries ?? []);
-              const isError = !!event.error;
+              const result = event.cancelled ? "Compaction cancelled \u2014 no checkpoint was created." : event.error ? `Error: ${event.error}` : formatSummariesResult(event.summaries ?? []);
+              const isError = !!event.error && !event.cancelled;
               for (let i = this.state.messages.length - 1; i >= 0; i--) {
                 const msg = this.state.messages[i];
                 if (msg.role !== "assistant" || !Array.isArray(msg.content)) {
@@ -11097,7 +11219,11 @@ var init_headless = __esm({
         this.applyPendingBlockUpdates();
       }
       async handleMessage(parsed, requestId) {
-        if (this.running || getInflightCompaction()) {
+        const foldIn = !this.running && !getInflightCompaction() && this.queue.length > 0 && !isAutomatedMessage(parsed.text ?? "");
+        if (foldIn) {
+          this.queue.releaseHeld();
+        }
+        if (this.running || getInflightCompaction() || foldIn) {
           const command = { ...parsed };
           if (requestId && command.requestId === void 0) {
             command.requestId = requestId;
@@ -11134,8 +11260,9 @@ var init_headless = __esm({
         return item.source === "user" && isAutomatedMessage(item.command.text ?? "");
       }
       /**
-       * Drain the queue in strict FIFO order. Caller must hold `running = true`.
-       * User messages arriving during the drain will be enqueued behind current items.
+       * Drain the queue in FIFO order over its deliverable items. Caller must hold
+       * `running = true`. User messages arriving during the drain will be enqueued
+       * behind current items.
        *
        * The queue serves two purposes with opposite delivery semantics:
        * - Sequencer: chain steps and sentinel-bearing user items are pipeline
@@ -11145,12 +11272,21 @@ var init_headless = __esm({
        *   merged turn, so the model reconciles all of it at once instead of
        *   burning a full turn per item (and possibly executing instructions a
        *   later queued message already amended).
+       *
+       * Held items are not in the delivery sequence at all: the drain starts at the
+       * first deliverable item and never merges across a held one. It skips rather
+       * than stops because a held message sits at the head of the array — stopping
+       * there would strand the chain steps and background results behind it.
        */
       async drainQueueLoop() {
-        while (this.queue.length > 0) {
-          const head = this.queue.peek();
+        for (; ; ) {
+          const at = this.queue.firstDeliverableIndex();
+          if (at === -1) {
+            return;
+          }
+          const head = this.queue.peekAt(at);
           if (head.command.action === "compact") {
-            this.queue.shift();
+            this.queue.takeAt(at);
             await triggerCompaction(this.state, this.config, {
               blocking: true,
               requestId: head.command.requestId,
@@ -11162,13 +11298,13 @@ var init_headless = __esm({
             continue;
           }
           if (head.source === "chain") {
-            const item = this.queue.shift();
+            const item = this.queue.takeAt(at);
             const rid = item.command.requestId ?? `chain-${Date.now()}`;
             await this.runSingleTurn(item.command, rid, true);
             continue;
           }
           if (this.isDrainBarrier(head)) {
-            const item = this.queue.shift();
+            const item = this.queue.takeAt(at);
             const rid = item.command.requestId ?? `user-${Date.now()}`;
             await this.runSingleTurn(item.command, rid, false, true);
             continue;
@@ -11176,8 +11312,8 @@ var init_headless = __esm({
           let n = 1;
           let batchOb = head.command.onboardingState;
           for (; ; n++) {
-            const it = this.queue.peekAt(n);
-            if (!it || it.source === "chain" || this.isDrainBarrier(it)) {
+            const it = this.queue.peekAt(at + n);
+            if (!it || it.held || it.source === "chain" || this.isDrainBarrier(it)) {
               break;
             }
             const ob = it.command.onboardingState;
@@ -11188,7 +11324,7 @@ var init_headless = __esm({
               batchOb = ob;
             }
           }
-          const batch = this.queue.shiftMany(n);
+          const batch = this.queue.takeRange(at, n);
           await this.runMergedTurn(batch);
         }
       }
@@ -11198,7 +11334,7 @@ var init_headless = __esm({
        * and by kickDrain (background-completion-initiated).
        */
       async resumeQueue() {
-        if (this.running || this.queue.length === 0) {
+        if (this.running || !this.queue.hasDeliverable()) {
           return;
         }
         this.running = true;
@@ -11217,7 +11353,7 @@ var init_headless = __esm({
        * racing any currently-synchronous path.
        */
       kickDrain() {
-        if (this.running || this.queue.length === 0) {
+        if (this.running || !this.queue.hasDeliverable()) {
           return;
         }
         setTimeout(() => this.resumeQueue(), 0);
@@ -11246,28 +11382,42 @@ var init_headless = __esm({
         };
       }
       /**
-       * Cancel the running turn and flush the follow-ups that belonged to it
-       * (`chain`/`background`), while preserving `source: 'user'` items — those are
-       * independent user intent, not tied to the aborted run. The preserved user
-       * messages run next: `executeTurn` swallows the abort, so `handleMessage`
-       * falls through to `drainQueueLoop` with `running` still held. Returns the
-       * flushed items (for the cancel command's resume/discard UX).
+       * Stop everything the user can see running: the turn, an in-flight
+       * compaction, and any external tool waiting on a result. Flushes the
+       * follow-ups that belonged to the turn (`chain`/`background`) and HOLDS the
+       * `source: 'user'` items — those are independent user intent, so they're
+       * kept, but they no longer run on their own.
+       *
+       * Holding is the difference between Stop working and Stop looking broken.
+       * These items used to drain immediately: `executeTurn` swallows the abort,
+       * so `handleMessage` fell through to `drainQueueLoop` with `running` still
+       * held and the next turn began in the same tick — the spinner never stopped,
+       * and every additional press hit a turn that had just started. They now wait
+       * in the queue card until the user sends again or promotes one.
        *
-       * Messages already absorbed into the in-flight merged turn are NOT
-       * preserved — they were delivered into the turn that's being cancelled and
-       * each gets a `{cancelled, absorbed:true}` terminal. Only items still
-       * sitting in the queue survive.
+       * A compaction is cancelled here too, unconditionally. It gates every queued
+       * message and outlives the turn that started it, so leaving it running means
+       * Stop can't reach idle. The cost is the summary work in flight; the forced
+       * gate re-compacts on the next turn if the context is still too big.
+       *
+       * Messages already absorbed into the in-flight merged turn are NOT held —
+       * they were delivered into the turn that's being cancelled and each gets a
+       * `{cancelled, absorbed:true}` terminal. Only items still sitting in the
+       * queue survive.
        */
       handleCancel() {
         if (this.currentAbort) {
           this.currentAbort.abort();
         }
+        const cancelledCompaction = cancelInflightCompaction();
         for (const [id, pending2] of this.pendingTools) {
           clearTimeout(pending2.timeout);
           pending2.resolve(USER_CANCELLED_RESULT);
           this.pendingTools.delete(id);
         }
-        return this.queue.removeWhere((item) => item.source !== "user");
+        const flushed = this.queue.removeWhere((item) => item.source !== "user");
+        const held = this.queue.holdWhere((item) => item.source === "user");
+        return { flushed, held, cancelledCompaction };
       }
       /**
        * Remove pending queued messages — all user messages, or one by id.
@@ -11376,12 +11526,14 @@ var init_headless = __esm({
           return;
         }
         if (action === "cancel") {
-          const cancelled = this.handleCancel();
+          const { flushed, held, cancelledCompaction } = this.handleCancel();
           this.emit(
             "completed",
             {
               success: true,
-              ...cancelled.length > 0 && { cancelledMessages: cancelled }
+              ...flushed.length > 0 && { cancelledMessages: flushed },
+              ...held.length > 0 && { heldMessages: held },
+              ...cancelledCompaction && { cancelledCompaction: true }
             },
             requestId
           );
@@ -11420,7 +11572,12 @@ var init_headless = __esm({
             );
             return;
           }
-          this.queue.setDelivery(id, delivery);
+          if (delivery === "asap") {
+            this.queue.promoteToFront(id);
+            this.kickDrain();
+          } else {
+            this.queue.setDelivery(id, delivery);
+          }
           this.emit("completed", { success: true }, requestId);
           return;
         }
@@ -11486,7 +11643,7 @@ var init_headless = __esm({
             }
             this.emit("completed", { success: true }, requestId);
           } catch (err) {
-            const error = err.message || "Compaction failed";
+            const error = err instanceof CompactionCancelledError ? "cancelled" : err.message || "Compaction failed";
             this.emit("completed", { success: false, error }, requestId);
           }
           return;
@@ -11504,7 +11661,7 @@ var init_headless = __esm({
             );
             return;
           }
-          if (this.queue.length === 0) {
+          if (!this.queue.hasDeliverable()) {
             this.emit("completed", { success: true }, requestId);
             return;
           }

package/dist/prompt/compiled/sdk-actions.md

@@ -153,4 +153,4 @@ Consider the ways in which AI can be incorporated into backend methods to solve
 
 ### Task Agents
 
-For multi-step tasks where the model needs to autonomously compose actions (research + scrape + generate, enrichment pipelines, content creation), use `runTask()` instead of chaining actions manually. It runs an agent loop and returns structured JSON. Its tools can include SDK actions as well as your app's own methods, so the agent can read your data to decide what to do next and write results back itself. Load the `taskAgents` skill before writing one — it is the full reference.
+For multi-step tasks where the model needs to autonomously compose actions (research + scrape + generate, enrichment pipelines, content creation), use `runTask()` instead of chaining actions manually. It runs an agent loop and returns structured JSON. Its tools can include SDK actions, your app's own methods, and inline functions defined at the call site, so the agent can read your data to decide what to do next and write results back itself. Load the `taskAgents` skill before writing one — it is the full reference.