@jpcasabiancai/cayenne 0.5.2 → 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
           });
         }
@@ -9925,6 +9950,9 @@ function worthRespawning(current, next) {
   if (next.state !== "ok") return next.state === "none" && current.state !== "none";
   return current.state !== "ok" || current.token !== next.token;
 }
+function refusedByPostgres(code) {
+  return typeof code === "string" && /^[0-9A-Z]{5}$/.test(code) && code !== UNIQUE_VIOLATION && code !== "40003" && !code.startsWith("08") && !code.startsWith("57P");
+}
 function assertTaskMode(mode) {
   if (TASK_REFUSED_MODES.has(mode)) {
     throw new Error(`VALIDATION: a task session cannot run in ${mode}`);
@@ -9962,7 +9990,7 @@ function shrink(event) {
       return null;
   }
 }
-var READ_ONLY_TEXT, REFRESH_WITHIN_MS, betweenTurns, UNREADABLE_MARK_CREDS, roundUsd, 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";
@@ -10003,7 +10031,10 @@ 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;
     ORPHANED_STATUSES = ["running", "awaiting_permission"];
     RESTARTABLE_STATUSES = /* @__PURE__ */ new Set(["idle", ...ORPHANED_STATUSES]);
     isAtOrBelow3 = (p, dir) => p === dir || p.startsWith(dir.endsWith(sep16) ? dir : `${dir}${sep16}`);
@@ -10604,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();
@@ -10966,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
@@ -11804,8 +11902,10 @@ 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(),
           changesVersion: this.nextChangesSeed(),
           watcher: null,
           docs: null,
@@ -11969,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
@@ -11982,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, {
@@ -11995,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,
@@ -12008,8 +12112,8 @@ var init_manager = __esm({
               m.parentToolUseId,
               m.raw
             );
-          })()
-        );
+          })();
+        });
         session.on(
           "permission",
           (rawReq) => guard(async () => {
@@ -12098,14 +12202,17 @@ 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 () => {
             if (live.provider === "claude") await this.recordCost(sessionId, live, r);
+            const seq = await lastSeq;
             const status = r.isError ? "error" : "idle";
             live.status = status;
             await this.updateSession(sessionId, { status, last_message_at: (/* @__PURE__ */ new Date()).toISOString() });
             const { authMode: _authMode, ...event } = r;
-            await this.broadcast(sessionId, { type: "result", seq: live.seq, ...event });
+            await this.broadcast(sessionId, { type: "result", seq, ...event });
             await this.broadcast(sessionId, {
               type: "session.status",
               status,
@@ -12213,36 +12320,55 @@ var init_manager = __esm({
           );
         });
       }
+      /**
+       * Write one `chat_messages` row and broadcast its `message` twin, in this session's write order.
+       *
+       * The step is queued on `live.writes` before this method first awaits, so two calls made back to
+       * back (the SDK hands a short turn's reply and result row over on one tick) insert and broadcast
+       * in call order: insert N and its broadcast both happen before insert N+1 starts. A caller on
+       * the prompt path may therefore wait for earlier rows' inserts — a database wait. It never
+       * waits on a relay send: `broadcast` returns once the relay has the event queued.
+       *
+       * Rejects with `PROVIDER_ERROR: persist failed: …` for this row only; the chain goes on.
+       */
       async persist(sessionId, live, role, content, providerUuid, parentToolUseId, raw) {
         const safeContent = this.secrets.redact(content);
         const safeRaw = this.secrets.redact(raw);
-        live.seq += 1;
-        const seq = live.seq;
-        const { data, error } = await this.deps.db.from("chat_messages").insert({
-          session_id: sessionId,
-          // Overwritten from the session by stamp_message_workspace; the insert policy still needs
-          // is_member(workspace_id) to see a non-null value.
-          workspace_id: this.deps.workspaceId,
-          seq,
-          role,
-          content: safeContent,
-          provider_uuid: providerUuid,
-          parent_tool_use_id: parentToolUseId,
-          raw: safeRaw
-        }).select(
-          "id, session_id, workspace_id, seq, role, content, provider_uuid, parent_tool_use_id, created_at"
-        ).single();
-        if (error || !data) {
-          throw new Error(`PROVIDER_ERROR: persist failed: ${error?.message ?? "no row"}`);
-        }
-        const row = {
-          ...data,
-          seq,
-          role,
-          content: safeContent
-        };
-        await this.broadcast(sessionId, { type: "message", message: row });
-        return row;
+        const step = live.writes.then(async () => {
+          const seq = live.seq + 1;
+          live.seq = seq;
+          const { data, error } = await this.deps.db.from("chat_messages").insert({
+            session_id: sessionId,
+            // Overwritten from the session by stamp_message_workspace; the insert policy still needs
+            // is_member(workspace_id) to see a non-null value.
+            workspace_id: this.deps.workspaceId,
+            seq,
+            role,
+            content: safeContent,
+            provider_uuid: providerUuid,
+            parent_tool_use_id: parentToolUseId,
+            raw: safeRaw
+          }).select(
+            "id, session_id, workspace_id, seq, role, content, provider_uuid, parent_tool_use_id, created_at"
+          ).abortSignal(AbortSignal.timeout(ROW_WRITE_TIMEOUT_MS)).single();
+          if (error || !data) {
+            if (refusedByPostgres(error?.code)) live.seq = seq - 1;
+            throw new Error(`PROVIDER_ERROR: persist failed: ${error?.message ?? "no row"}`);
+          }
+          const row = {
+            ...data,
+            seq,
+            role,
+            content: safeContent
+          };
+          await this.broadcast(sessionId, { type: "message", message: row });
+          return row;
+        });
+        live.writes = step.then(
+          () => void 0,
+          () => void 0
+        );
+        return step;
       }
       /**
        * The highest `chat_messages.seq` this session has, or 0. A failed read is fatal rather than

package/package.json

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