@skaile/workspaces 3.7.0 → 3.7.2

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

@@ -2,7 +2,7 @@ import { scrubPoisonedTranscript, resolveClaudeConfigDir, SUPPORTED_CLOUDS, buil
 import { dispatchCapability } from '../../chunk-RRVQAE5D.js';
 import { fetchProviderModels } from '../../chunk-V34ZEXSE.js';
 import { AuthError, classifyClaudeSdkError, reclassifyAuthAsAccountUnavailable, AccountUnavailableError } from '../../chunk-GAH4YRCI.js';
-import { BUILTIN_DRIVER_CATALOG, AgentDriver, getBridgeLogger } from '../../chunk-AFA7NYN2.js';
+import { BUILTIN_DRIVER_CATALOG, AgentDriver, getBridgeLogger } from '../../chunk-32TJ55W5.js';
 import '../../chunk-6E6PKKAD.js';
 import '../../chunk-AZPXCHDK.js';
 import '../../chunk-F3HNW354.js';
@@ -159,13 +159,62 @@ if (typeof globalThis.require === "undefined") {
   }
 }
 function freshRetryBudget() {
-  return { staleResume: false, poison: false, auth: false };
+  return { staleResume: false, poison: false, auth: false, queryEnded: false };
 }
+var QueryEndedBeforeTurnError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "QueryEndedBeforeTurnError";
+  }
+};
 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 DEFAULT_FIRST_MESSAGE_STALL_MS = 5 * 6e4;
+function firstMessageStallMs() {
+  const raw = Number(process.env.SKAILE_FIRST_MESSAGE_STALL_MS);
+  const value = Number.isFinite(raw) && raw > 0 ? raw : DEFAULT_FIRST_MESSAGE_STALL_MS;
+  return Math.min(value, turnStallMs());
+}
+var RECYCLE_TURNS_FRACTION = 0.8;
+var MIN_RECYCLE_HEADROOM = 5;
+var PushableInputStream = class {
+  queue = [];
+  wake = null;
+  done = false;
+  consumed = false;
+  /** `true` once {@link end} ran — pushes are no longer possible. */
+  get ended() {
+    return this.done;
+  }
+  push(message) {
+    if (this.done) throw new Error("input stream already ended");
+    this.queue.push(message);
+    this.wake?.();
+  }
+  /** Finish the iterable; the SDK responds by closing the CLI's stdin. Idempotent. */
+  end() {
+    if (this.done) return;
+    this.done = true;
+    this.wake?.();
+  }
+  async *[Symbol.asyncIterator]() {
+    if (this.consumed) throw new Error("input stream already has a consumer");
+    this.consumed = true;
+    while (true) {
+      while (this.queue.length > 0) {
+        yield this.queue.shift();
+      }
+      if (this.done) return;
+      await new Promise((resolve) => {
+        this.wake = resolve;
+      });
+      this.wake = null;
+    }
+  }
+};
 var ABORT_GRACE_MS = 3e3;
 var claudeBinaryCache;
 var claudeBinaryResolved = false;
@@ -191,8 +240,26 @@ var ClaudeSdkDriver = class extends AgentDriver {
   emittedSanitizedLen = 0;
   /** Set once the streaming text of the current message classifies as a self-healable auth render. */
   suppressingAuthStream = false;
-  /** Active query — may stay alive between turns if streamInput works. */
+  /** Active query — stays alive between turns (streaming input mode). */
   query = null;
+  /**
+   * The live query's prompt stream. Created in {@link startQuery}, fed one user
+   * message per turn, and ended wherever the query is dropped — an ended stream
+   * with a live query means the CLI's stdin is closed and the query can never
+   * accept another turn.
+   */
+  inputStream = null;
+  /**
+   * `true` once any SDK message arrived after the current turn's watchdog was
+   * armed — flips the stall budget from the first-message tier to the mid-turn
+   * ceiling. See {@link armTurnStallWatchdog}.
+   */
+  firstSdkMessageSeen = false;
+  /**
+   * `num_turns` reported by the most recent result message. Feeds
+   * {@link shouldRecycleQuery}; reset on every fresh spawn.
+   */
+  lastNumTurns = null;
   /**
    * OS pid of the CLI subprocess backing `query`, captured via
    * `spawnClaudeCodeProcess` in {@link startQuery}. Feeds
@@ -251,6 +318,22 @@ var ClaudeSdkDriver = class extends AgentDriver {
   _lastContextTokens = null;
   /** Context window size from the most recent result's modelUsage. */
   _contextWindow = null;
+  /**
+   * The SDK's `total_cost_usd` from the most recently seen result message —
+   * cumulative over the whole SDK run/session, not per-turn. Diffed against
+   * the next result's total to derive the per-turn delta.
+   */
+  _lastCumulativeCostUsd = 0;
+  /** Per-turn cost delta derived from `total_cost_usd`, emitted as the `result` event's `costUsd`. */
+  _lastTurnCostUsd = 0;
+  /**
+   * Bumped by every `startQuery()` spawn. Lets `captureResultUsage` detect a
+   * fresh CLI process deterministically, instead of only inferring it from
+   * `total_cost_usd` happening to decrease.
+   */
+  _querySpawnGeneration = 0;
+  /** Spawn generation `_lastCumulativeCostUsd` was captured under. */
+  _costTrackingGeneration = -1;
   /**
    * `true` when the active credential is a Claude Code OAuth subscription
    * (no API key in config) rather than a raw `ANTHROPIC_API_KEY`. Set on
@@ -309,8 +392,8 @@ var ClaudeSdkDriver = class extends AgentDriver {
    * Sends a user message to the Claude Agent SDK and resolves when the turn completes.
    *
    * If a live SDK query already exists (from a prior turn in this session) the message
-   * is fed via `streamInput()` for efficient multi-turn continuity. Otherwise a new query
-   * is started applying the resume chain described in the class-level remarks.
+   * is pushed into its persistent prompt stream (streaming input mode). Otherwise a new
+   * query is started applying the resume chain described in the class-level remarks.
    *
    * @param message - Plain-text user prompt.
    * @throws {Error} When the SDK reports a fatal error that cannot be auto-recovered.
@@ -339,7 +422,7 @@ var ClaudeSdkDriver = class extends AgentDriver {
     if (!this.sdk) await this.start();
     this.authSelfHealUsed = _budget.auth;
     let retrying = false;
-    const isFirstAttempt = !_budget.staleResume && !_budget.poison && !_budget.auth;
+    const isFirstAttempt = !_budget.staleResume && !_budget.poison && !_budget.auth && !_budget.queryEnded;
     if (isFirstAttempt) {
       this._lastTokens = null;
       this._lastContextTokens = null;
@@ -349,14 +432,16 @@ var ClaudeSdkDriver = class extends AgentDriver {
     this.emittedSanitizedLen = 0;
     this.suppressingAuthStream = false;
     this.turnCompleted = false;
+    if (this.query && (this.inputStream == null || this.inputStream.ended || this.shouldRecycleQuery())) {
+      this.recycleQueryForNextTurn();
+    }
     const turnPromise = new Promise((resolve, reject) => {
       this.turnResolve = resolve;
       this.turnReject = reject;
     });
     try {
-      if (this.query) {
-        const userMsg = this.buildUserMessage(message);
-        this.query.streamInput(this.singleItemIterable(userMsg));
+      if (this.query && this.inputStream) {
+        this.inputStream.push(this.buildUserMessage(message));
       } else {
         await this.startQuery(message);
       }
@@ -370,6 +455,11 @@ var ClaudeSdkDriver = class extends AgentDriver {
     try {
       await turnPromise;
     } catch (err) {
+      if (!_budget.queryEnded && err instanceof QueryEndedBeforeTurnError) {
+        this.log.warn("turn was enqueued into an ending query; replaying on a fresh one");
+        retrying = true;
+        return this.runPrompt(message, { ..._budget, queryEnded: true });
+      }
       const errMsg = err instanceof Error ? err.message : String(err);
       const isStaleResume = !_budget.staleResume && /No conversation found with session ID/i.test(errMsg);
       if (isStaleResume) {
@@ -406,13 +496,22 @@ var ClaudeSdkDriver = class extends AgentDriver {
    * 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.
+   *
+   * Two budget tiers: until the first SDK message of the turn arrives the
+   * (small) {@link firstMessageStallMs} budget applies — silence there means
+   * the query is deaf, not busy. Once anything arrives, the (large)
+   * {@link turnStallMs} ceiling takes over, because a long-running tool call
+   * legitimately produces no SDK messages. The budget is re-read every tick, so
+   * the first message flips tiers without re-arming.
    */
   armTurnStallWatchdog() {
     this.disarmTurnStallWatchdog();
     if (this.turnCompleted || this.turnReject == null) return;
-    const budget = turnStallMs();
+    this.firstSdkMessageSeen = false;
+    const currentBudget = () => this.firstSdkMessageSeen ? turnStallMs() : firstMessageStallMs();
     const tick = () => {
       if (this.turnCompleted || this.turnReject == null) return;
+      const budget = currentBudget();
       if (this.hasPendingQuestion()) {
         this.turnStallTimer = setTimeout(tick, budget);
         this.turnStallTimer.unref?.();
@@ -427,7 +526,7 @@ var ClaudeSdkDriver = class extends AgentDriver {
       this.onTurnStalled(idleMs);
     };
     this.lastSdkMessageAt = Date.now();
-    this.turnStallTimer = setTimeout(tick, budget);
+    this.turnStallTimer = setTimeout(tick, currentBudget());
     this.turnStallTimer.unref?.();
   }
   disarmTurnStallWatchdog() {
@@ -443,7 +542,10 @@ var ClaudeSdkDriver = class extends AgentDriver {
    */
   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.log.error("turn stalled \u2014 no SDK message received; resetting the query", {
+      idleMs,
+      firstMessageOfTurnSeen: this.firstSdkMessageSeen
+    });
     const descendants = this.snapshotDescendantPids();
     this.hardResetQuery();
     this.killPids(descendants);
@@ -465,6 +567,62 @@ var ClaudeSdkDriver = class extends AgentDriver {
    * abort signal) runs, then {@link killPids} after.
    */
   hardResetQuery() {
+    this.endInputStream();
+    if (this.query) {
+      try {
+        this.query.close();
+      } catch {
+      }
+      this.query = null;
+    }
+    this.abortController?.abort();
+  }
+  /**
+   * End the persistent prompt stream (the SDK responds by closing the CLI's
+   * stdin) and forget it. Called wherever the query is dropped so a stale
+   * stream can never be pushed into. Safe to call with no stream.
+   */
+  endInputStream() {
+    if (this.inputStream) {
+      this.inputStream.end();
+      this.inputStream = null;
+    }
+  }
+  /**
+   * `maxTurns` counts agentic turns, but whether the CLI resets that count per
+   * user turn or accumulates it across a resident streaming session is
+   * undocumented. This guard is correct under either semantics: once the last
+   * result's reported `num_turns` is within {@link RECYCLE_TURNS_FRACTION}
+   * headroom of the ceiling, the resident query is dropped at the next turn
+   * boundary and the prompt respawns with `--resume` (which restarts the
+   * count). Under per-turn semantics this fires only when a single prompt
+   * nearly exhausted the budget by itself — where a recycle is harmless.
+   */
+  shouldRecycleQuery() {
+    if (this.lastNumTurns == null) return false;
+    const max = this.config.maxTurns ?? 15;
+    const threshold = Math.min(
+      Math.max(1, Math.floor(max * RECYCLE_TURNS_FRACTION)),
+      Math.max(1, max - MIN_RECYCLE_HEADROOM)
+    );
+    return this.lastNumTurns >= threshold;
+  }
+  /**
+   * Gracefully drop the resident query between turns so the next prompt starts
+   * a fresh CLI resuming the same session. Deliberately does NOT sweep the
+   * CLI's descendant processes: a between-turns recycle mirrors the legacy
+   * spawn-per-turn behavior, where the CLI's background tasks (`run_in_background`
+   * dev servers) outlive the turn boundary. Note they become orphans no later
+   * sweep can reach — snapshotDescendantPids walks from `cliProcessPid`, which
+   * the next spawn overwrites — exactly as in legacy spawn-per-turn.
+   */
+  recycleQueryForNextTurn() {
+    this.log.info("recycling resident query before the next turn", {
+      reportedTurns: this.lastNumTurns,
+      maxTurns: this.config.maxTurns ?? 15,
+      inputStreamEnded: this.inputStream?.ended ?? null
+    });
+    this.endInputStream();
     if (this.query) {
       try {
         this.query.close();
@@ -550,6 +708,7 @@ var ClaudeSdkDriver = class extends AgentDriver {
     this.sessionId = "";
     this.hasSession = false;
     this.query = null;
+    this.endInputStream();
     this.config.resumeSessionId = void 0;
     this.turnResolve = null;
     this.turnReject = null;
@@ -596,6 +755,7 @@ var ClaudeSdkDriver = class extends AgentDriver {
         fatal: false
       });
       this.query = null;
+      this.endInputStream();
       this.turnResolve = null;
       this.turnReject = null;
       this.running = false;
@@ -636,6 +796,7 @@ var ClaudeSdkDriver = class extends AgentDriver {
     if (refreshed) {
       this.log.info("credentials refreshed; retrying prompt");
       this.query = null;
+      this.endInputStream();
       this.turnResolve = null;
       this.turnReject = null;
       this.running = false;
@@ -719,6 +880,7 @@ var ClaudeSdkDriver = class extends AgentDriver {
     return "default";
   }
   async startQuery(message) {
+    this._querySpawnGeneration++;
     this.abortController = new AbortController();
     await this.preventivelyScrubTranscript();
     const cloud = this.resolveCloud();
@@ -838,8 +1000,11 @@ var ClaudeSdkDriver = class extends AgentDriver {
       options.env = { ...baseEnv, ...this.config.env ?? {}, ANTHROPIC_API_KEY: apiKey };
     }
     const { query } = this.sdk;
+    this.inputStream = new PushableInputStream();
+    this.inputStream.push(this.buildUserMessage(message));
+    this.lastNumTurns = null;
     const queryArgs = {
-      prompt: message,
+      prompt: this.inputStream,
       options
     };
     if (apiKey) queryArgs.apiKey = apiKey;
@@ -1023,11 +1188,14 @@ var ClaudeSdkDriver = class extends AgentDriver {
    * If it ends unexpectedly, query is nulled so the next prompt() restarts.
    */
   async consumeMessages() {
+    const servedQuery = this.query;
     void this.fetchSlashCommands();
     try {
-      for await (const msg of this.query) {
+      for await (const msg of servedQuery) {
+        if (this.query !== servedQuery) break;
         if (this.abortController?.signal.aborted) break;
         this.lastSdkMessageAt = Date.now();
+        this.firstSdkMessageSeen = true;
         this.captureSessionId(msg);
         this.handleSdkMessage(msg);
         if (msg.type === "result" && !msg.is_error) {
@@ -1035,11 +1203,29 @@ var ClaudeSdkDriver = class extends AgentDriver {
         }
       }
     } catch (err) {
-      this.handleConsumerError(err);
+      if (this.query === servedQuery) {
+        this.handleConsumerError(err);
+      } else {
+        this.log.debug("stale consumer error after query replacement; ignoring", {
+          error: err instanceof Error ? err.message : String(err)
+        });
+      }
     } finally {
       this.log.debug("query generator ended");
-      this.completeTurn();
-      this.query = null;
+      if (this.query === servedQuery) {
+        this.query = null;
+        this.endInputStream();
+        const neverDispatched = !this.turnCompleted && this.turnReject != null && !this.firstSdkMessageSeen && !this.abortController?.signal.aborted;
+        if (neverDispatched) {
+          this.rejectTurnSilently(
+            new QueryEndedBeforeTurnError(
+              "The model process ended before this turn was dispatched."
+            )
+          );
+        } else {
+          this.completeTurn();
+        }
+      }
     }
   }
   /** Capture the SDK session id from a message (first one assigns hasSession). */
@@ -1102,6 +1288,27 @@ var ClaudeSdkDriver = class extends AgentDriver {
       });
     }
   }
+  /**
+   * Reject the current turn WITHOUT emitting an `agent-event: error`.
+   *
+   * The one legitimate use is a turn that is about to be replayed: the host
+   * must not see an error for a failure the driver is itself recovering from
+   * (the same reasoning as `failTurn`'s auth self-heal deferral). Ordering
+   * mirrors {@link failTurn} — settle the promise before touching anything
+   * else — so a turn can never be left pending.
+   *
+   * Anything a caller should actually learn about goes through `failTurn`.
+   */
+  rejectTurnSilently(err) {
+    this.disarmTurnStallWatchdog();
+    this.turnCompleted = true;
+    if (this.turnReject) {
+      const reject = this.turnReject;
+      this.turnResolve = null;
+      this.turnReject = null;
+      reject(err);
+    }
+  }
   /**
    * Signal the current turn as failed. When a structured `detail` is
    * supplied, the AgentEvent carries the category + hint so downstream
@@ -1302,6 +1509,8 @@ var ClaudeSdkDriver = class extends AgentDriver {
    * tokens — surface all four to consumers that want a complete picture.
    */
   captureResultUsage(msg) {
+    const numTurns = msg.num_turns;
+    if (typeof numTurns === "number") this.lastNumTurns = numTurns;
     const usage = msg.usage;
     if (usage) {
       const tokens = {};
@@ -1318,6 +1527,11 @@ var ClaudeSdkDriver = class extends AgentDriver {
       const first = Object.values(modelUsage)[0];
       if (first?.contextWindow) this._contextWindow = first.contextWindow;
     }
+    const totalCostUsd = msg.total_cost_usd ?? 0;
+    const freshCostSession = this._querySpawnGeneration !== this._costTrackingGeneration || totalCostUsd < this._lastCumulativeCostUsd;
+    this._lastTurnCostUsd = freshCostSession ? totalCostUsd : totalCostUsd - this._lastCumulativeCostUsd;
+    this._lastCumulativeCostUsd = totalCostUsd;
+    this._costTrackingGeneration = this._querySpawnGeneration;
   }
   /** Emit the message_end (if any) + success result event for a clean turn. */
   handleSuccessResult(msg) {
@@ -1333,7 +1547,7 @@ var ClaudeSdkDriver = class extends AgentDriver {
       type: "result",
       subtype: msg.subtype,
       summary: result ?? "Task completed",
-      costUsd: msg.total_cost_usd ?? 0,
+      costUsd: this._lastTurnCostUsd,
       ...this._lastTokens ? { tokens: this._lastTokens } : {}
     });
   }
@@ -1354,6 +1568,10 @@ var ClaudeSdkDriver = class extends AgentDriver {
       subtype: msg.subtype,
       errors
     });
+    const awaitingFollowUpThrow = looseMsg.is_error === true && errors.length === 0;
+    if (!this.turnCompleted && !awaitingFollowUpThrow) {
+      this.completeTurn();
+    }
   }
   /**
    * Classify + route an `is_error` result payload: auth-shaped errors throw
@@ -1391,7 +1609,7 @@ var ClaudeSdkDriver = class extends AgentDriver {
   // ---------------------------------------------------------------------------
   // Helpers
   // ---------------------------------------------------------------------------
-  /** Build an SDKUserMessage for streamInput. */
+  /** Build an SDKUserMessage for the persistent prompt stream. */
   buildUserMessage(text) {
     return {
       type: "user",
@@ -1403,10 +1621,6 @@ var ClaudeSdkDriver = class extends AgentDriver {
       session_id: this.sessionId
     };
   }
-  /** Wrap a single value as an AsyncIterable that yields once. */
-  async *singleItemIterable(item) {
-    yield item;
-  }
   mapAssistantMessage(msg) {
     const contentBlocks = [];
     const toolCalls = [];
@@ -1467,6 +1681,7 @@ var ClaudeSdkDriver = class extends AgentDriver {
    */
   async abort() {
     this.denyPendingQuestion("turn aborted before the question was answered");
+    if (!this.running && this.query) return;
     const abortedQuery = this.query;
     const abortedController = this.abortController;
     const descendants = this.snapshotDescendantPids();
@@ -1507,6 +1722,7 @@ var ClaudeSdkDriver = class extends AgentDriver {
   kill() {
     this.denyPendingQuestion("session terminated before the question was answered");
     const descendants = this.snapshotDescendantPids();
+    this.endInputStream();
     if (this.query) {
       try {
         this.query.close();
@@ -1539,6 +1755,7 @@ var ClaudeSdkDriver = class extends AgentDriver {
   async resetSession() {
     this.denyPendingQuestion("session reset before the question was answered");
     const descendants = this.snapshotDescendantPids();
+    this.endInputStream();
     if (this.query) {
       try {
         this.query.close();
@@ -1553,6 +1770,9 @@ var ClaudeSdkDriver = class extends AgentDriver {
     this._lastTokens = null;
     this._lastContextTokens = null;
     this._contextWindow = null;
+    this._lastCumulativeCostUsd = 0;
+    this._lastTurnCostUsd = 0;
+    this._costTrackingGeneration = -1;
   }
   /**
    * Build allowedTools / disallowedTools options from AgentConfig.tools.