agentbox-sdk 0.1.513 → 0.1.514

package/README.md

@@ -123,12 +123,26 @@ while the harness has ended its turn and the run stays open only for those
 tasks (or, with an empty set, for the wake-up the CLI queues for a task that
 finished mid-turn) — and settles the run on the follow-up turn's result
 instead of the first one. Once background work has been seen, a turn end
-settles the run only after a 15s grace with no new turn, and a final
+settles the run when Claude emits `session_state_changed: idle` and the live
+task set is empty. AgentBox enables this documented CLI event with
+`CLAUDE_CODE_EMIT_SESSION_STATE_EVENTS=1`; there is no extra model call or
+fixed completion delay ([upstream opt-in documentation](https://github.com/anthropics/claude-agent-sdk-typescript/blob/main/CHANGELOG.md#0283)). Older/custom CLIs that never emit session state use
+a 15s grace as a compatibility fallback. A final
 `background.tasks` with `tasks: []` and `waiting: false` precedes the settle.
 `backgroundTaskTimeoutMs` bounds the total time spent waiting across the run:
 default 30 minutes, `0` settles at the first turn end as before, `Infinity`
 waits forever. On expiry the tasks are stopped best-effort and the run
 completes with the last turn's text.
+Tasks marked ambient by Claude (such as live-update watchers) do not keep the
+run waiting. The SDK's full task snapshots take precedence over task start and
+finish events, whose ordering relative to those snapshots is unspecified.
+
+AgentBox does not inject a Stop-hook prompt or infer from the answer that a
+running task is unwanted. A genuinely live polling helper keeps the run open
+until it finishes, is stopped, or reaches the wait budget. Unlike the interactive
+CLI, an AgentBox run owns the query lifetime: completing it closes the process.
+Keep the streaming input open while waiting so background continuations retain
+their hooks, permissions, and SDK MCP control channel.
 
 Codex owns command polling (`write_stdin`), yielded code-mode waits (`wait`),
 and subagent waits (`wait_agent`). AgentBox finishes an ordinary Codex run on

package/dist/agents/index.js

@@ -4,7 +4,7 @@ import {
   getAgentLayout,
   harnessCapabilities,
   resolveHarnessCommand
-} from "../chunk-XJWZR2NR.js";
+} from "../chunk-D33LRRN7.js";
 import "../chunk-775FIGGL.js";
 import {
   AGENT_RESERVED_PORTS,

package/dist/{chunk-XJWZR2NR.js → chunk-D33LRRN7.js}

@@ -1859,17 +1859,21 @@ var BackgroundTaskTracker = class {
   pendingWakeups = /* @__PURE__ */ new Map();
   afterResult = false;
   seenBackgroundWork = false;
+  hasTaskSnapshot = false;
   liveTasks() {
-    return [...this.tasks.values(), ...this.wakeups.values()];
+    return [
+      ...[...this.tasks.values()].filter(({ ambient }) => !ambient).map(({ task }) => task),
+      ...this.wakeups.values()
+    ];
   }
   /**
    * True once any background task or scheduled wakeup was live in this run.
    * The CLI queues a wake-up for every task that finishes and delivers it as
    * a new turn once the model is idle — including tasks that finished
    * mid-turn, whose queued turn starts right after that turn's `result`
-   * with nothing live and nothing observable in between. After background
-   * work has been seen, a `result` is therefore never the end of the run on
-   * its own; only the grace passing without a new turn is.
+   * with nothing live in between. After background work has been seen, wait
+   * for session_state_changed/idle with an empty live set. Older CLIs that
+   * never emit session state use an idle grace as a compatibility fallback.
    */
   hasSeenBackgroundWork() {
     return this.seenBackgroundWork;
@@ -1911,6 +1915,7 @@ var BackgroundTaskTracker = class {
     const id = String(m.task_id ?? "");
     switch (m.subtype) {
       case "background_tasks_changed":
+        this.hasTaskSnapshot = true;
         this.tasks.clear();
         for (const entry of asArray(m.tasks)) {
           const task = asRecord2(entry);
@@ -1918,13 +1923,13 @@ var BackgroundTaskTracker = class {
         }
         return false;
       case "task_started":
-        if (m.is_backgrounded === true && !m.owned_by_subagent) this.addTask(m);
+        if (!this.hasTaskSnapshot && m.is_backgrounded === true && !m.owned_by_subagent) this.addTask(m);
         return false;
       case "task_notification":
-        this.tasks.delete(id);
+        if (!this.hasTaskSnapshot) this.tasks.delete(id);
         return false;
       case "task_updated":
-        if (DONE_STATUSES.has(String(asRecord2(m.patch)?.status)))
+        if (!this.hasTaskSnapshot && DONE_STATUSES.has(String(asRecord2(m.patch)?.status)))
           this.tasks.delete(id);
         return false;
       case "init":
@@ -1936,11 +1941,15 @@ var BackgroundTaskTracker = class {
   addTask(task) {
     const id = String(task.task_id ?? "");
     if (!id) return;
-    this.seenBackgroundWork = true;
+    const ambient = task.ambient === true || task.skip_transcript === true;
+    if (!ambient) this.seenBackgroundWork = true;
     this.tasks.set(id, {
-      id,
-      type: String(task.task_type ?? "task"),
-      description: String(task.description ?? "")
+      ambient,
+      task: {
+        id,
+        type: String(task.task_type ?? "task"),
+        description: String(task.description ?? "")
+      }
     });
   }
   ingestToolUses(m) {
@@ -2021,7 +2030,7 @@ var BackgroundWait = class {
 };
 
 // src/agents/providers/claude-code.ts
-var DAEMON_PROTOCOL_VERSION = "5";
+var DAEMON_PROTOCOL_VERSION = "8";
 var DAEMON_PORT = 43180;
 var DAEMON_PATH = "/tmp/agentbox/claude-code/daemon.mjs";
 var DAEMON_LOG_PATH = "/tmp/agentbox/claude-code/daemon.log";
@@ -2130,7 +2139,7 @@ function createClaudeCodeDaemonScript() {
   return `import http from "node:http";
 import { execSync } from "node:child_process";
 import { existsSync, readFileSync } from "node:fs";
-import { timingSafeEqual } from "node:crypto";
+import { randomUUID, timingSafeEqual } from "node:crypto";
 import { query, getSessionInfo } from "@anthropic-ai/claude-agent-sdk";
 
 const VERSION = ${version};
@@ -2774,6 +2783,7 @@ var ClaudeCodeAgentAdapter = class {
       IS_SANDBOX: "1"
     };
     applyCliBackgroundWaitCeiling(env);
+    env.CLAUDE_CODE_EMIT_SESSION_STATE_EVENTS ??= "1";
     const customHeaders = request.options.customHeaders;
     if (customHeaders && Object.keys(customHeaders).length > 0) {
       const serialized = Object.entries(customHeaders).map(([name, value]) => `${name}: ${value}`).join("\n");
@@ -2890,6 +2900,7 @@ ${serialized}` : serialized;
         { messageId: initialUuid }
       )
     );
+    const tracker = new BackgroundTaskTracker();
     const permissionMessages = async function* () {
       for await (const item of parseNdjsonStream(response.body)) {
         const control = item;
@@ -2905,7 +2916,7 @@ ${serialized}` : serialized;
         if (!reply.ok) throw new Error(`Claude permission response failed: ${reply.status}`);
       }
     };
-    await consumeClaudeMessages(request, sink, permissionMessages(), executeStartedAt, cleanup, () => cancelled);
+    await consumeClaudeMessages(request, sink, permissionMessages(), executeStartedAt, cleanup, () => cancelled, {}, tracker);
     return async () => void 0;
   }
   /**
@@ -2966,16 +2977,16 @@ ${serialized}` : serialized;
     }
   }
 };
-async function consumeClaudeMessages(request, sink, messages, executeStartedAt, cleanup, wasCancelled = () => false, wait = {}) {
+async function consumeClaudeMessages(request, sink, messages, executeStartedAt, cleanup, wasCancelled = () => false, wait = {}, tracker = new BackgroundTaskTracker()) {
   let accumulatedText = "";
   let streamedThinkingChars = 0;
   let sawResult = false;
+  let sawSessionState = false;
   let firstStreamEventLogged = false;
   let firstTextDeltaLogged = false;
   let lastTerminalReason;
   let lastIsError = false;
   const rawPayloads = [];
-  const tracker = new BackgroundTaskTracker();
   const timeoutMs = resolveBackgroundTaskTimeoutMs(request.options.backgroundTaskTimeoutMs);
   const graceMs = wait.graceMs ?? BACKGROUND_TASK_GRACE_MS;
   let pendingWait;
@@ -3047,7 +3058,10 @@ async function consumeClaudeMessages(request, sink, messages, executeStartedAt,
         endWait();
       }
       emitTasks(tracker.liveTasks(), pendingWait !== void 0);
-      pendingWait?.setIdle(tracker.liveTasks().length === 0);
+      const sessionState = message.type === "system" && message.subtype === "session_state_changed" ? message.state : void 0;
+      if (sessionState) sawSessionState = true;
+      pendingWait?.setIdle(!sawSessionState && tracker.liveTasks().length === 0);
+      if (sessionState === "idle" && pendingWait && tracker.liveTasks().length === 0) break;
       if (message.type === "system") {
         const sub = message.subtype;
         if (sub === "init") {
@@ -3169,7 +3183,7 @@ async function consumeClaudeMessages(request, sink, messages, executeStartedAt,
         debugClaude("\u2605 turn ended with %d background task(s); waiting", live.length);
         endWait();
         pendingWait = new BackgroundWait(graceMs, Math.max(0, timeoutMs - waitedMs));
-        pendingWait.setIdle(live.length === 0);
+        pendingWait.setIdle(!sawSessionState && live.length === 0);
         emitTasks(live, true);
         continue;
       }
@@ -3243,6 +3257,7 @@ async function executeNativeClaude(request, sink, wait = {}) {
   const prompt = new AsyncQueue();
   const sessionId = request.run.resumeSessionId ?? randomUUID();
   const controller = new AbortController();
+  const tracker = new BackgroundTaskTracker();
   let handle;
   let processHandle;
   let stopped;
@@ -3262,6 +3277,7 @@ async function executeNativeClaude(request, sink, wait = {}) {
   prompt.push({ type: "user", uuid: messageId, message: { role: "user", content: mapToClaudeUserContent(input) }, parent_tool_use_id: null });
   const hostEnv = Object.fromEntries(Object.entries({ ...process.env, ...request.options.env }).filter((entry) => entry[1] !== void 0));
   applyCliBackgroundWaitCeiling(hostEnv);
+  hostEnv.CLAUDE_CODE_EMIT_SESSION_STATE_EVENTS ??= "1";
   if (request.options.customHeaders) {
     const headers = Object.entries(request.options.customHeaders).map(([name, value]) => `${name}: ${value}`).join("\n");
     hostEnv.ANTHROPIC_CUSTOM_HEADERS = [hostEnv.ANTHROPIC_CUSTOM_HEADERS, headers].filter(Boolean).join("\n");
@@ -3344,7 +3360,7 @@ async function executeNativeClaude(request, sink, wait = {}) {
       stopTasks: async (ids) => {
         await Promise.all(ids.map((id) => live.stopTask(id).catch(() => void 0)));
       }
-    });
+    }, tracker);
   } catch (error) {
     await stop();
     if (cancelled) sink.cancel();

package/dist/index.js

@@ -4,7 +4,7 @@ import {
   getAgentLayout,
   harnessCapabilities,
   resolveHarnessCommand
-} from "./chunk-XJWZR2NR.js";
+} from "./chunk-D33LRRN7.js";
 import {
   ProviderLogAssembler,
   createNormalizedEvent,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentbox-sdk",
-  "version": "0.1.513",
+  "version": "0.1.514",
   "description": "Swappable coding agents and sandbox providers for Bun and TypeScript.",
   "license": "MIT",
   "repository": {
@@ -59,7 +59,7 @@
     "bun": ">=1.1.0"
   },
   "dependencies": {
-    "@anthropic-ai/claude-agent-sdk": "0.2.141",
+    "@anthropic-ai/claude-agent-sdk": "0.3.274",
     "@daytonaio/sdk": "^0.171.0",
     "@types/debug": "^4.1.13",
     "@vercel/sandbox": "2.0.0-beta.13",