@jpcasabiancai/cayenne 0.5.3 → 0.5.4

package/dist/cli.js

@@ -7753,7 +7753,15 @@ async function askGuard(guard, toolName2, input) {
     return GUARD_FAILED;
   }
 }
-var SESSION_FLAG_SETTINGS, GUARD_FAILED, ASK_TOOL_REASON, ClaudeSession;
+function asInterrupted(row) {
+  return {
+    ...row,
+    content: row.content.map(
+      (block) => block.type === "result" ? { ...block, isError: false, text: INTERRUPTED } : block
+    )
+  };
+}
+var SESSION_FLAG_SETTINGS, GUARD_FAILED, ASK_TOOL_REASON, INTERRUPTED, STOPPED_TURN, ClaudeSession;
 var init_session2 = __esm({
   "src/claude/session.ts"() {
     "use strict";
@@ -7768,6 +7776,8 @@ var init_session2 = __esm({
     };
     GUARD_FAILED = "Refused: the runner could not check this tool call.";
     ASK_TOOL_REASON = "This session was started from a task, so every shell command needs the member's approval.";
+    INTERRUPTED = "interrupted";
+    STOPPED_TURN = "error_during_execution after a requested stop: recorded as interrupted";
     ClaudeSession = class extends EventEmitter {
       constructor(opts) {
         super();
@@ -7786,6 +7796,13 @@ var init_session2 = __esm({
       /** `null` until `accountInfo()` answers, and for good when it cannot. */
       authMode = null;
       authAsked = false;
+      /** A prompt is waiting for its turn, or a turn began (`init`), and no result has closed it. */
+      turnOpen = false;
+      /**
+       * `interrupt()` or `stop()` was asked of the open turn. The CLI reports a turn cut short as
+       * `error_during_execution`; with this set, that result is the stop landing, not a failure.
+       */
+      stopAsked = false;
       start() {
         if (this.q) throw new Error("VALIDATION: session already started");
         const queryFn = this.opts.queryFn ?? sdkQuery;
@@ -7869,6 +7886,7 @@ var init_session2 = __esm({
           })),
           { type: "text", text }
         ] : text;
+        this.turnOpen = true;
         this.inbox.push({
           type: "user",
           message: { role: "user", content },
@@ -7885,6 +7903,7 @@ var init_session2 = __esm({
         return true;
       }
       async interrupt() {
+        if (this.turnOpen) this.stopAsked = true;
         await this.q?.interrupt();
       }
       async setPermissionMode(mode) {
@@ -7901,6 +7920,7 @@ var init_session2 = __esm({
         for (const id of [...this.pending.keys()]) {
           this.expire(id, "session stopped");
         }
+        if (this.turnOpen) this.stopAsked = true;
         void this.q?.interrupt().catch(() => void 0);
         const killer = setTimeout(() => this.abort.abort(), 5e3);
         await this.pumping;
@@ -7955,6 +7975,7 @@ ${this.stderrTail.join("\n")}` : "";
       }
       route(msg) {
         if (msg.type === "system" && msg.subtype === "init") {
+          this.turnOpen = true;
           this.providerSessionId = msg.session_id;
           this.lookUpAuthMode();
           this.emit("init", {
@@ -7974,15 +7995,19 @@ ${this.stderrTail.join("\n")}` : "";
           });
           return;
         }
+        const stopped = msg.type === "result" && this.stopAsked && msg.subtype === "error_during_execution";
+        if (stopped) logger.info({ providerSessionId: this.providerSessionId }, STOPPED_TURN);
         const normalized = normalizeSdkMessage(msg);
-        if (normalized) this.emit("message", normalized);
+        if (normalized) this.emit("message", stopped ? asInterrupted(normalized) : normalized);
         if (msg.type === "result") {
+          this.turnOpen = false;
+          this.stopAsked = false;
           this.emit("result", {
-            isError: msg.is_error,
+            isError: stopped ? false : msg.is_error,
             durationMs: msg.duration_ms,
             numTurns: msg.num_turns,
             totalCostUsd: msg.total_cost_usd,
-            stopReason: msg.stop_reason,
+            stopReason: stopped ? INTERRUPTED : msg.stop_reason,
             authMode: this.authMode
           });
         }
@@ -9965,7 +9990,7 @@ function shrink(event) {
       return null;
   }
 }
-var READ_ONLY_TEXT, REFRESH_WITHIN_MS, betweenTurns, UNREADABLE_MARK_CREDS, roundUsd, UNIQUE_VIOLATION, ROW_WRITE_TIMEOUT_MS, ORPHANED_STATUSES, RESTARTABLE_STATUSES, isAtOrBelow3, DENY_MESSAGE_MAX, EXIT_ERROR_MAX, INITIAL_PROMPT_MAX, TASK_SKILL_LOOKUP_MS, TASK_REFUSED_MODES, OWNER_DRIVEN_KINDS, REPO_OWNER_ONLY, REPO_NO_DUPLICATE, PROVIDER_SESSION_ID, REPO_WORKTREE_GONE, TASK_ASK_TOOLS, MEMORY_PREAMBLE, MEMORY_SOURCE, wrapMemory, PATH_INPUT_TOOLS, PATH_INPUT_KEYS, isRecord, errorCode, SessionManager;
+var READ_ONLY_TEXT, REFRESH_WITHIN_MS, betweenTurns, UNREADABLE_MARK_CREDS, DRAINED_AFTER_MS, roundUsd, UNIQUE_VIOLATION, ROW_WRITE_TIMEOUT_MS, ORPHANED_STATUSES, RESTARTABLE_STATUSES, isAtOrBelow3, DENY_MESSAGE_MAX, EXIT_ERROR_MAX, INITIAL_PROMPT_MAX, TASK_SKILL_LOOKUP_MS, TASK_REFUSED_MODES, OWNER_DRIVEN_KINDS, REPO_OWNER_ONLY, REPO_NO_DUPLICATE, PROVIDER_SESSION_ID, REPO_WORKTREE_GONE, TASK_ASK_TOOLS, MEMORY_PREAMBLE, MEMORY_SOURCE, wrapMemory, PATH_INPUT_TOOLS, PATH_INPUT_KEYS, isRecord, errorCode, SessionManager;
 var init_manager = __esm({
   "src/sessions/manager.ts"() {
     "use strict";
@@ -10006,6 +10031,7 @@ var init_manager = __esm({
       state: "unavailable",
       readOnlyText: READ_ONLY_UNAVAILABLE
     };
+    DRAINED_AFTER_MS = 2e3;
     roundUsd = (usd) => Math.round(usd * 1e6) / 1e6;
     UNIQUE_VIOLATION = "23505";
     ROW_WRITE_TIMEOUT_MS = 3e4;
@@ -10609,6 +10635,7 @@ var init_manager = __esm({
           );
           await this.setStatus(sessionId, "running");
           live.session.prompt(text, p.clientUuid, staged);
+          this.turnHandedOver(live);
           this.deps.timings?.prompted(sessionId);
         } catch (err) {
           staged.discard();
@@ -10971,12 +10998,78 @@ var init_manager = __esm({
       async interrupt(sessionId) {
         const live = this.live.get(sessionId);
         if (live) {
-          await this.provider(() => live.session.interrupt());
+          const { turns } = live;
+          turns.stops = turns.owed;
+          turns.chased = false;
+          turns.early = turns.owed > 0 && !turns.begun && !live.stopping && !live.dropping;
+          if (turns.early) {
+            this.sendStop(sessionId, live);
+            if (live.status === "running") await this.setStatus(sessionId, "idle");
+            return {};
+          }
+          try {
+            await this.provider(() => live.session.interrupt());
+          } catch (err) {
+            turns.stops = 0;
+            throw err;
+          }
           return {};
         }
         await this.settleOrphans([sessionId]);
         return {};
       }
+      /** A stop nobody waits on: a provider that is starting, or between turns, may answer late. */
+      sendStop(sessionId, live) {
+        void live.session.interrupt().catch(
+          (err) => this.deps.log.warn(
+            { err: err instanceof Error ? err.message : String(err), sessionId },
+            "a stop sent ahead of its turn failed"
+          )
+        );
+      }
+      /** A prompt went to the provider. */
+      turnHandedOver(live) {
+        const { turns } = live;
+        const leftover = live.provider === "claude" && turns.stops === 0 && turns.drainedAt !== null && Date.now() - turns.drainedAt > DRAINED_AFTER_MS;
+        if (leftover) {
+          turns.owed = 0;
+          turns.stops = 0;
+        }
+        turns.drainedAt = null;
+        turns.owed += 1;
+      }
+      /** The provider announced a turn (`init`): if a Stop covers it, this is where it lands. */
+      turnBegan(sessionId, live) {
+        if (live.provider !== "claude") return;
+        const { turns } = live;
+        turns.drainedAt = null;
+        if (turns.owed > 0) turns.begun = true;
+        if (turns.stops > 0 && turns.early) this.sendStop(sessionId, live);
+      }
+      /**
+       * The provider produced output. For a turn stopped before it began that means the stop did not
+       * land (a backend with no `init` per turn, or a stop that was lost): it is sent once more, and
+       * `true` tells the caller the row must say `running` again, since a turn is.
+       */
+      turnOutput(sessionId, live) {
+        const { turns } = live;
+        turns.drainedAt = null;
+        if (turns.owed > 0) turns.begun = true;
+        if (turns.stops === 0 || !turns.early || turns.chased) return false;
+        turns.chased = true;
+        this.sendStop(sessionId, live);
+        return live.status === "idle";
+      }
+      /** A turn ended: whatever a Stop still covers is behind it, and has not begun. */
+      turnEnded(live) {
+        const { turns } = live;
+        turns.owed = Math.max(0, turns.owed - 1);
+        turns.stops = Math.max(0, turns.stops - 1);
+        turns.begun = false;
+        turns.drainedAt = Date.now();
+        turns.early = true;
+        turns.chased = false;
+      }
       /**
        * Put rows on this runner that claim a turn in progress back to `idle`, for the chats that have
        * no live session here — at boot every one of them, since nothing is live yet, and again when
@@ -11809,6 +11902,7 @@ var init_manager = __esm({
           permissions: /* @__PURE__ */ new Map(),
           cwd: opts.cwd,
           stopping: false,
+          turns: { owed: 0, begun: false, drainedAt: null, stops: 0, early: false, chased: false },
           dropping: null,
           inflight: /* @__PURE__ */ new Set(),
           writes: Promise.resolve(),
@@ -11975,9 +12069,12 @@ var init_manager = __esm({
           live.inflight.add(task);
           void task.finally(() => live.inflight.delete(task));
         };
-        session.on(
-          "init",
-          (init) => guard(async () => {
+        const output = () => {
+          if (this.turnOutput(sessionId, live)) guard(() => this.setStatus(sessionId, "running"))();
+        };
+        session.on("init", (init) => {
+          this.turnBegan(sessionId, live);
+          return guard(async () => {
             await this.updateSession(sessionId, {
               provider_session_id: init.providerSessionId,
               model: init.model
@@ -11988,9 +12085,10 @@ var init_manager = __esm({
               providerSessionId: init.providerSessionId,
               model: init.model
             });
-          })()
-        );
+          })();
+        });
         session.on("stream", (s) => {
+          output();
           this.deps.timings?.streamed(sessionId);
           guard(
             () => this.broadcast(sessionId, {
@@ -12001,9 +12099,9 @@ var init_manager = __esm({
             })
           )();
         });
-        session.on(
-          "message",
-          (m) => guard(async () => {
+        session.on("message", (m) => {
+          if (m.role === "assistant" || m.role === "tool") output();
+          return guard(async () => {
             if (m.role === "user" && m.providerUuid && live.echoed.has(m.providerUuid)) return;
             await this.persist(
               sessionId,
@@ -12014,8 +12112,8 @@ var init_manager = __esm({
               m.parentToolUseId,
               m.raw
             );
-          })()
-        );
+          })();
+        });
         session.on(
           "permission",
           (rawReq) => guard(async () => {
@@ -12104,6 +12202,7 @@ var init_manager = __esm({
           })()
         );
         session.on("result", (r) => {
+          this.turnEnded(live);
           this.deps.timings?.finished(sessionId);
           const lastSeq = live.writes.then(() => live.seq);
           guard(async () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jpcasabiancai/cayenne",
-  "version": "0.5.3",
+  "version": "0.5.4",
   "files": [
     "dist/cli.js"
   ],