@skaile/workspaces 1.13.0 → 1.13.1

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Changelog
 
+## 1.13.1
+
+### Patch Changes
+
+- [#431](https://github.com/skaile-ai/workspaces/pull/431) [`a9951a9`](https://github.com/skaile-ai/workspaces/commit/a9951a9ea6f108388e15a40d51a837685812ae18) Thanks [@peteralbert](https://github.com/peteralbert)! - fix(bridge): recover from a Claude SDK turn that never emits a result — a
+  per-turn inactivity watchdog (`SKAILE_TURN_STALL_MS`, default 30 min) tears the
+  wedged query down and rejects the turn, and `abort()` now forces the teardown
+  when the consumer loop refuses to unwind.
+
 ## 1.13.0
 
 ### Minor Changes

package/dist/bridge/drivers/claude-sdk.js

@@ -2,7 +2,7 @@ import { SUPPORTED_CLOUDS, buildClaudeCloudEnv } from '../../chunk-ISQWMBKD.js';
 import { dispatchCapability } from '../../chunk-RRVQAE5D.js';
 import { fetchProviderModels } from '../../chunk-BMQKMOQY.js';
 import { AuthError, classifyClaudeSdkError, reclassifyAuthAsAccountUnavailable, AccountUnavailableError } from '../../chunk-GAH4YRCI.js';
-import { BUILTIN_DRIVER_CATALOG, AgentDriver, getBridgeLogger } from '../../chunk-YM5P2P4R.js';
+import { BUILTIN_DRIVER_CATALOG, AgentDriver, getBridgeLogger } from '../../chunk-XG3JOTAE.js';
 import '../../chunk-6E6PKKAD.js';
 import '../../chunk-JB35MVBN.js';
 import '../../chunk-NSBPE2FW.js';
@@ -311,6 +311,12 @@ if (typeof globalThis.require === "undefined") {
 function freshRetryBudget() {
   return { staleResume: false, poison: false, auth: false };
 }
+var DEFAULT_TURN_STALL_MS = 30 * 6e4;
+function turnStallMs() {
+  const raw = Number(process.env.SKAILE_TURN_STALL_MS);
+  return Number.isFinite(raw) && raw > 0 ? raw : DEFAULT_TURN_STALL_MS;
+}
+var ABORT_GRACE_MS = 3e3;
 var claudeBinaryCache;
 var claudeBinaryResolved = false;
 var ClaudeSdkDriver = class extends AgentDriver {
@@ -343,6 +349,10 @@ var ClaudeSdkDriver = class extends AgentDriver {
   turnReject = null;
   /** Guards against duplicate agent_end emissions per turn. */
   turnCompleted = false;
+  /** `Date.now()` of the most recent SDK message — the watchdog's liveness signal. */
+  lastSdkMessageAt = 0;
+  /** Armed while a turn is in flight; trips when the SDK goes silent for too long. */
+  turnStallTimer = null;
   /**
    * Mirror of the in-flight {@link prompt} call's auth retry budget: `false`
    * while the `onAuthError` self-heal is still available, `true` once it has
@@ -471,6 +481,7 @@ var ClaudeSdkDriver = class extends AgentDriver {
       this.running = false;
       throw err;
     }
+    this.armTurnStallWatchdog();
     try {
       await turnPromise;
     } catch (err) {
@@ -499,12 +510,79 @@ var ClaudeSdkDriver = class extends AgentDriver {
       throw err;
     } finally {
       if (!retrying) {
+        this.disarmTurnStallWatchdog();
         this.turnResolve = null;
         this.turnReject = null;
         this.running = false;
       }
     }
   }
+  /**
+   * Arm the per-turn inactivity watchdog. Self-rescheduling rather than a single
+   * absolute timer so any mid-turn SDK message pushes the deadline out; the
+   * timer is `unref`'d so an armed watchdog never holds the process open.
+   */
+  armTurnStallWatchdog() {
+    this.disarmTurnStallWatchdog();
+    if (this.turnCompleted || this.turnReject == null) return;
+    const budget = turnStallMs();
+    const tick = () => {
+      if (this.turnCompleted || this.turnReject == null) return;
+      if (this.hasPendingQuestion()) {
+        this.turnStallTimer = setTimeout(tick, budget);
+        this.turnStallTimer.unref?.();
+        return;
+      }
+      const idleMs = Date.now() - this.lastSdkMessageAt;
+      if (idleMs < budget) {
+        this.turnStallTimer = setTimeout(tick, budget - idleMs);
+        this.turnStallTimer.unref?.();
+        return;
+      }
+      this.onTurnStalled(idleMs);
+    };
+    this.lastSdkMessageAt = Date.now();
+    this.turnStallTimer = setTimeout(tick, budget);
+    this.turnStallTimer.unref?.();
+  }
+  disarmTurnStallWatchdog() {
+    if (this.turnStallTimer) {
+      clearTimeout(this.turnStallTimer);
+      this.turnStallTimer = null;
+    }
+  }
+  /**
+   * The SDK went silent mid-turn. Tear the query down so the *next* prompt
+   * starts a fresh one (a live-but-deaf query would otherwise swallow every
+   * subsequent `streamInput`), then reject the turn with an actionable message.
+   */
+  onTurnStalled(idleMs) {
+    const idle = idleMs < 6e4 ? `${Math.round(idleMs / 1e3)}s` : `${Math.round(idleMs / 6e4)}m`;
+    this.log.error("turn stalled \u2014 no SDK message received; resetting the query", { idleMs });
+    this.hardResetQuery();
+    this.failTurn(
+      new Error(
+        `Agent stalled: no response from the model process for ${idle}. The conversation is intact \u2014 send your message again.`
+      )
+    );
+  }
+  /**
+   * Drop a query that will not unwind on its own, keeping the session intact.
+   *
+   * Deliberately does NOT clear `sessionId` / `hasSession` — the next
+   * `startQuery()` must resume the same SDK session so the conversation
+   * survives. That is what separates this from {@link kill}.
+   */
+  hardResetQuery() {
+    if (this.query) {
+      try {
+        this.query.close();
+      } catch {
+      }
+      this.query = null;
+    }
+    this.abortController?.abort();
+  }
   /**
    * Side-effects of the stale-resume recovery path: emit the resume-outcome and
    * non-fatal error events, then reset session state so the recursive prompt()
@@ -855,6 +933,7 @@ var ClaudeSdkDriver = class extends AgentDriver {
     }
     if (pending.answered >= pending.questionTexts.length) {
       this.pendingQuestion = null;
+      this.lastSdkMessageAt = Date.now();
       pending.resolve({
         behavior: "allow",
         updatedInput: { ...pending.originalInput, answers: pending.answers }
@@ -872,6 +951,7 @@ var ClaudeSdkDriver = class extends AgentDriver {
     const pending = this.pendingQuestion;
     if (!pending) return;
     this.pendingQuestion = null;
+    this.lastSdkMessageAt = Date.now();
     pending.resolve({ behavior: "deny", message: reason });
   }
   /**
@@ -979,6 +1059,7 @@ var ClaudeSdkDriver = class extends AgentDriver {
     try {
       for await (const msg of this.query) {
         if (this.abortController?.signal.aborted) break;
+        this.lastSdkMessageAt = Date.now();
         this.captureSessionId(msg);
         this.handleSdkMessage(msg);
         if (msg.type === "result" && !msg.is_error) {
@@ -1039,6 +1120,7 @@ var ClaudeSdkDriver = class extends AgentDriver {
   completeTurn() {
     if (this.turnCompleted) return;
     this.turnCompleted = true;
+    this.disarmTurnStallWatchdog();
     if (this.turnResolve) {
       this.turnResolve();
       this.turnResolve = null;
@@ -1085,6 +1167,7 @@ var ClaudeSdkDriver = class extends AgentDriver {
    * exposed this hang).
    */
   failTurn(err, detail) {
+    this.disarmTurnStallWatchdog();
     if (this.turnReject) {
       this.turnReject(err);
       this.turnResolve = null;
@@ -1390,7 +1473,9 @@ var ClaudeSdkDriver = class extends AgentDriver {
    * signals the underlying `AbortController`. The driver remains usable after abort.
    *
    * @remarks Best-effort: if `interrupt()` throws (e.g. query already ended) the
-   *   error is silently swallowed and the abort signal is still sent.
+   *   error is silently swallowed and the abort signal is still sent. A query
+   *   whose generator refuses to unwind within {@link ABORT_GRACE_MS} is torn
+   *   down outright — see {@link hardResetQuery}.
    */
   async abort() {
     this.denyPendingQuestion("turn aborted before the question was answered");
@@ -1400,8 +1485,17 @@ var ClaudeSdkDriver = class extends AgentDriver {
       } catch {
       }
     }
-    if (this.abortController) {
-      this.abortController.abort();
+    this.abortController?.abort();
+    const deadline = Date.now() + ABORT_GRACE_MS;
+    while (this.query && Date.now() < deadline) {
+      await new Promise((resolve) => {
+        setTimeout(resolve, 100).unref?.();
+      });
+    }
+    if (this.query) {
+      this.log.warn("query did not unwind after abort; forcing teardown");
+      this.hardResetQuery();
+      this.completeTurn();
     }
   }
   /** `true` while the driver is processing a `prompt()` call. */