agentbox-sdk 0.1.317 → 0.1.319

package/dist/agents/index.js

@@ -2,8 +2,8 @@ import {
   Agent,
   agentboxRoot,
   getAgentLayout
-} from "../chunk-75KPGNTE.js";
-import "../chunk-2DH5OVG4.js";
+} from "../chunk-2IHQY3WC.js";
+import "../chunk-775FIGGL.js";
 import {
   AGENT_RESERVED_PORTS,
   collectAllAgentReservedPorts

package/dist/{chunk-75KPGNTE.js → chunk-2IHQY3WC.js}

@@ -2,7 +2,7 @@ import {
   createNormalizedEvent,
   normalizeRawAgentEvent,
   toAISDKStream
-} from "./chunk-2DH5OVG4.js";
+} from "./chunk-775FIGGL.js";
 import {
   AgentBoxError,
   AsyncQueue,
@@ -2328,6 +2328,7 @@ var ClaudeCodeAgentAdapter = class {
       )
     );
     let accumulatedText = "";
+    let streamedThinkingChars = 0;
     let pendingMessages = 1;
     let firstStreamEventLogged = false;
     let firstTextDeltaLogged = false;
@@ -2399,8 +2400,15 @@ var ClaudeCodeAgentAdapter = class {
             );
           }
           const partial = message;
+          if (partial.parent_tool_use_id) continue;
+          const streamType = partial.event?.type;
+          if (streamType === "message_start") {
+            accumulatedText = "";
+            streamedThinkingChars = 0;
+          }
           const { text, thinking } = extractStreamDeltas(partial);
           if (thinking) {
+            streamedThinkingChars += thinking.length;
             sink.emitEvent(
               createNormalizedEvent(
                 "reasoning.delta",
@@ -2430,8 +2438,9 @@ var ClaudeCodeAgentAdapter = class {
         }
         if (message.type === "assistant") {
           const asst = message;
+          if (asst.parent_tool_use_id) continue;
           const thinking = extractAssistantThinking(asst);
-          if (thinking) {
+          if (thinking && streamedThinkingChars === 0) {
             sink.emitEvent(
               createNormalizedEvent(
                 "reasoning.delta",
@@ -2571,6 +2580,7 @@ var ClaudeCodeAgentAdapter = class {
 };
 
 // src/agents/providers/codex.ts
+import crypto from "crypto";
 import path9 from "path";
 
 // src/agents/transports/app-server.ts
@@ -2797,6 +2807,61 @@ function codexConfigDir(options) {
 }
 var REMOTE_CODEX_APP_SERVER_PORT = 43181;
 var REMOTE_CODEX_APP_SERVER_ID = "shared-app-server";
+var CODEX_APP_SERVER_TOKEN_FILENAME = "codex-app-server-token";
+function defaultRemoteCodexTokenPath() {
+  return path9.posix.join(
+    agentboxRoot(AgentProvider.Codex, true),
+    CODEX_APP_SERVER_TOKEN_FILENAME
+  );
+}
+var codexAppServerTokenCache = /* @__PURE__ */ new WeakMap();
+async function readCodexAppServerTokenFile(sandbox, tokenFilePath) {
+  const result = await sandbox.run(
+    `if [ -f ${shellQuote(tokenFilePath)} ]; then cat ${shellQuote(tokenFilePath)}; fi`
+  );
+  if (result.exitCode !== 0) {
+    return void 0;
+  }
+  const value = result.stdout.trim();
+  return value.length > 0 ? value : void 0;
+}
+function resolveCodexAppServerToken(sandbox, tokenFilePath, create) {
+  let cached = codexAppServerTokenCache.get(sandbox);
+  if (!cached) {
+    cached = (async () => {
+      const existing = await readCodexAppServerTokenFile(
+        sandbox,
+        tokenFilePath
+      );
+      if (existing) {
+        return existing;
+      }
+      if (create) {
+        return crypto.randomBytes(32).toString("hex");
+      }
+      throw new Error(
+        `Codex app-server token file is missing at ${tokenFilePath}. setup() must run before connecting to the codex app-server.`
+      );
+    })().catch((error) => {
+      codexAppServerTokenCache.delete(sandbox);
+      throw error;
+    });
+    codexAppServerTokenCache.set(sandbox, cached);
+  }
+  return cached;
+}
+function ensureCodexAppServerToken(sandbox, tokenFilePath) {
+  return resolveCodexAppServerToken(sandbox, tokenFilePath, true);
+}
+function getCodexAppServerToken(sandbox, tokenFilePath = defaultRemoteCodexTokenPath()) {
+  return resolveCodexAppServerToken(sandbox, tokenFilePath, false);
+}
+function withCodexAppServerAuthHeaders(base, token) {
+  return {
+    ...base,
+    Authorization: `Bearer ${token}`
+  };
+}
 function compactEnv(values) {
   return Object.fromEntries(
     Object.entries(values).filter(([, value]) => value !== void 0)
@@ -3131,9 +3196,10 @@ async function withCodexAppServer(request, body) {
     );
   }
   const previewUrl = await sandbox.getPreviewLink(REMOTE_CODEX_APP_SERVER_PORT);
+  const token = await getCodexAppServerToken(sandbox);
   const transport = await connectJsonRpcWebSocket(
     toRemoteCodexWebSocketUrl(previewUrl),
-    { headers: sandbox.previewHeaders }
+    { headers: withCodexAppServerAuthHeaders(sandbox.previewHeaders, token) }
   );
   const client = new JsonRpcLineClient(
     transport.source,
@@ -3219,7 +3285,19 @@ async function setupCodex(request) {
       ...sharedTarget.env,
       ...options.provider?.env ?? {}
     });
-    const { artifacts: serverArtifacts } = buildArtifactsFor(sharedTarget);
+    const tokenFilePath = path9.posix.join(
+      sharedTarget.layout.rootDir,
+      CODEX_APP_SERVER_TOKEN_FILENAME
+    );
+    const appServerToken = await ensureCodexAppServerToken(
+      sandbox,
+      tokenFilePath
+    );
+    const { artifacts: baseServerArtifacts } = buildArtifactsFor(sharedTarget);
+    const serverArtifacts = [
+      ...baseServerArtifacts,
+      { path: tokenFilePath, content: appServerToken }
+    ];
     const { artifacts: skillArtifacts2, installCommands: installCommands2 } = await prepareSkillArtifacts(provider, options.skills, target2.layout);
     const enableRtk2 = options.enableRtk === true;
     const daemonInfo = {
@@ -3260,6 +3338,7 @@ async function setupCodex(request) {
           `mkdir -p ${shellQuote(sharedTarget.layout.rootDir)}`,
           `if curl -fsS http://127.0.0.1:${REMOTE_CODEX_APP_SERVER_PORT}/readyz >/dev/null 2>&1; then exit 0; fi`,
           `if [ -f ${shellQuote(pidFilePath)} ]; then kill "$(cat ${shellQuote(pidFilePath)})" >/dev/null 2>&1 || true; rm -f ${shellQuote(pidFilePath)}; fi`,
+          `chmod 600 ${shellQuote(tokenFilePath)}`,
           `(${[
             `nohup ${[
               "env",
@@ -3268,7 +3347,15 @@ async function setupCodex(request) {
                 [
                   "app-server",
                   "--listen",
-                  `ws://0.0.0.0:${REMOTE_CODEX_APP_SERVER_PORT}`
+                  `ws://0.0.0.0:${REMOTE_CODEX_APP_SERVER_PORT}`,
+                  // Auth on non-loopback listeners is opt-in in codex; without
+                  // these flags the 0.0.0.0 app-server accepts unauthenticated
+                  // clients. Requires codex >= 0.133 (`--ws-auth` flag); older
+                  // pinned binaries will fail to launch on the unknown arg.
+                  "--ws-auth",
+                  "capability-token",
+                  "--ws-token-file",
+                  tokenFilePath
                 ],
                 options
               )
@@ -3343,9 +3430,10 @@ async function createRuntime(request, inputParts) {
       "getPreviewLink app-server",
       () => sandbox.getPreviewLink(REMOTE_CODEX_APP_SERVER_PORT)
     );
+    const token = await getCodexAppServerToken(sandbox);
     const transport = await connectRemoteCodexAppServer(
       toRemoteCodexWebSocketUrl(previewUrl),
-      sandbox.previewHeaders
+      withCodexAppServerAuthHeaders(sandbox.previewHeaders, token)
     );
     debugCodex("\u2605 codex transport established");
     return {
@@ -3790,12 +3878,74 @@ var CodexAgentAdapter = class {
 };
 
 // src/agents/providers/opencode.ts
+import { createHash as createHash2 } from "crypto";
 import path10 from "path";
 var SANDBOX_OPENCODE_PORT = 4096;
 var LOCAL_OPENCODE_PORT = 4096;
 var SANDBOX_OPENCODE_READY_TIMEOUT_MS = 9e4;
 var LOCAL_OPENCODE_READY_TIMEOUT_MS = 2e4;
 var SHARED_OPENCODE_TARGET_ID = "shared-opencode-server";
+var LLM_API_KEY_ENV_VARS = [
+  "OPENROUTER_API_KEY",
+  "OPENAI_API_KEY",
+  "ANTHROPIC_API_KEY",
+  "GOOGLE_GENERATIVE_AI_API_KEY",
+  "GEMINI_API_KEY"
+];
+function hashLlmApiKeys(env) {
+  const hasher = createHash2("sha256");
+  for (const key of LLM_API_KEY_ENV_VARS) {
+    if (env?.[key] !== void 0) {
+      hasher.update(`${key}=${env[key]}
+`);
+    }
+  }
+  return hasher.digest("hex");
+}
+async function killLocalOpenCodeServer() {
+  await time(debugOpencode, "kill local opencode server", async () => {
+    const killer = spawnCommand({
+      command: "sh",
+      args: [
+        "-c",
+        `lsof -ti tcp:${LOCAL_OPENCODE_PORT} | xargs kill 2>/dev/null || true`
+      ]
+    });
+    await killer.wait().catch(() => void 0);
+    await waitFor(
+      async () => {
+        try {
+          const res = await fetch(
+            `http://127.0.0.1:${LOCAL_OPENCODE_PORT}/global/health`
+          );
+          return !res.ok;
+        } catch {
+          return true;
+        }
+      },
+      { timeoutMs: 5e3, intervalMs: 200 }
+    ).catch(() => void 0);
+  });
+}
+async function killSandboxOpenCodeServer(sandbox, pidFilePath, cwd, port) {
+  await time(debugOpencode, "kill sandbox opencode server", async () => {
+    await sandbox.run(
+      `kill -- -"$(cat ${shellQuote(pidFilePath)})" 2>/dev/null || kill "$(cat ${shellQuote(pidFilePath)})" 2>/dev/null || true`,
+      { cwd, timeoutMs: 5e3 }
+    ).catch(() => void 0);
+    const deadline = Date.now() + 5e3;
+    while (Date.now() < deadline) {
+      const probe = await sandbox.run(
+        `curl -fsS --max-time 2 http://127.0.0.1:${port}/global/health >/dev/null 2>&1`,
+        { cwd, timeoutMs: 5e3 }
+      );
+      if (probe.exitCode !== 0) {
+        return;
+      }
+      await sleep(200);
+    }
+  });
+}
 function toRawEvent3(runId, payload, type) {
   return {
     provider: AgentProvider.OpenCode,
@@ -3891,6 +4041,10 @@ function buildOpenCodeConfig(options, interactiveApproval) {
   const googleBaseUrl = options.env?.GOOGLE_BASE_URL;
   const openRouterBaseUrl = options.env?.OPENROUTER_BASE_URL;
   const openRouterPlugins = options.openRouterPlugins && options.openRouterPlugins.length > 0 ? options.openRouterPlugins : void 0;
+  const openRouterExtraBody = {
+    transforms: ["middle-out"],
+    ...openRouterPlugins ? { plugins: openRouterPlugins } : {}
+  };
   return {
     $schema: "https://opencode.ai/config.json",
     ...mcpConfig ? { mcp: mcpConfig } : {},
@@ -3899,7 +4053,7 @@ function buildOpenCodeConfig(options, interactiveApproval) {
       openrouter: {
         options: {
           baseURL: openRouterBaseUrl || "https://openrouter.ai/api/v1",
-          ...openRouterPlugins ? { plugins: openRouterPlugins } : {}
+          extraBody: openRouterExtraBody
         }
       },
       ...googleBaseUrl ? { google: { options: { baseURL: googleBaseUrl } } } : {}
@@ -3949,7 +4103,10 @@ async function ensureSandboxOpenCodeServer(request) {
       artifacts: allArtifacts,
       installCommands,
       daemon: daemonInfo,
-      extras: [`enableRtk:${enableRtk}`]
+      extras: [
+        `enableRtk:${enableRtk}`,
+        `apiKeys:${hashLlmApiKeys(options.env)}`
+      ]
     });
     if (await preflightSetup(target, setupId, daemonInfo)) {
       debugOpencode("opencode setup() preflight hit \u2014 skipping");
@@ -3990,6 +4147,7 @@ async function ensureSandboxOpenCodeServer(request) {
         `disown 2>/dev/null || true`
       ].join(" ")})`
     ].join(" && ");
+    await killSandboxOpenCodeServer(sandbox, pidFilePath, options.cwd, port);
     const launchResult = await time(
       debugOpencode,
       "spawn opencode serve",
@@ -4030,16 +4188,6 @@ async function ensureSandboxOpenCodeServer(request) {
 }
 async function ensureLocalOpenCodeServer(request) {
   const options = request.options;
-  try {
-    await waitForHttpReady(
-      `http://127.0.0.1:${LOCAL_OPENCODE_PORT}/global/health`,
-      { timeoutMs: 1e3 }
-    );
-    debugOpencode("local opencode server already running \u2014 reusing");
-    return;
-  } catch {
-    debugOpencode("local opencode server not running \u2014 cold-spawning");
-  }
   const plugins = assertHooksSupported(request.provider, options);
   assertCommandsSupported(request.provider, options.commands);
   const interactiveApproval = isInteractiveApproval(options);
@@ -4072,14 +4220,23 @@ async function ensureLocalOpenCodeServer(request) {
       content: JSON.stringify(openCodeConfig, null, 2)
     }
   ];
+  const daemonInfo = {
+    port: LOCAL_OPENCODE_PORT,
+    healthPath: "/global/health"
+  };
   const setupId = computeSetupId({
     artifacts: allArtifacts,
-    installCommands
+    installCommands,
+    daemon: daemonInfo,
+    extras: [`apiKeys:${hashLlmApiKeys(options.env)}`]
   });
-  const preflightHit = await preflightSetup(target, setupId);
-  if (!preflightHit) {
-    await applyDifferentialSetup(target, allArtifacts, installCommands);
+  if (await preflightSetup(target, setupId, daemonInfo)) {
+    debugOpencode("local opencode server up-to-date \u2014 reusing");
+    return;
   }
+  debugOpencode("local opencode server drifted/absent \u2014 (re)spawning");
+  await applyDifferentialSetup(target, allArtifacts, installCommands);
+  await killLocalOpenCodeServer();
   spawnCommand({
     command: options.provider?.binary ?? "opencode",
     args: [

package/dist/{chunk-2DH5OVG4.js → chunk-775FIGGL.js}

@@ -189,9 +189,35 @@ function isRecord(value) {
 function clone(value) {
   return JSON.parse(JSON.stringify(value));
 }
+function isCodexNoiseEvent(method) {
+  if (!method) return false;
+  if (method.startsWith("mcpServer/")) return true;
+  return method.toLowerCase().includes("delta");
+}
 var CodexLogAssembler = class {
   byItemId = /* @__PURE__ */ new Map();
   textByItemId = /* @__PURE__ */ new Map();
+  // Non-item events (turn/completed usage, error notifications, thread
+  // responses). Returned by `process()` for the live channel; tracked here so
+  // `getSnapshots()` — the end-of-run persistence source — keeps them too.
+  passThroughSnapshots = [];
+  // First-seen chronological order across items and passthroughs.
+  snapshotOrder = [];
+  trackItem(itemId, snapshot) {
+    if (!this.byItemId.has(itemId)) {
+      this.snapshotOrder.push({ kind: "item", id: itemId });
+    }
+    this.byItemId.set(itemId, snapshot);
+  }
+  pushPassThrough(event) {
+    const passthrough = clone(event);
+    this.snapshotOrder.push({
+      kind: "passthrough",
+      index: this.passThroughSnapshots.length
+    });
+    this.passThroughSnapshots.push(passthrough);
+    return clone(passthrough);
+  }
   process(event) {
     if (!isRecord(event)) {
       return [];
@@ -201,7 +227,7 @@ var CodexLogAssembler = class {
     const item = isRecord(params.item) ? clone(params.item) : null;
     if (method === "item/started" || method === "item/updated" || method === "item/completed") {
       if (item && typeof item.id === "string") {
-        this.byItemId.set(item.id, clone(event));
+        this.trackItem(item.id, clone(event));
         const text = typeof item.text === "string" ? item.text : void 0;
         if (text !== void 0) {
           this.textByItemId.set(item.id, text);
@@ -247,7 +273,8 @@ var CodexLogAssembler = class {
         })
       ];
     }
-    return [clone(event)];
+    if (isCodexNoiseEvent(method)) return [];
+    return [this.pushPassThrough(event)];
   }
   /**
    * Repopulate state from a sequence of previously-assembled snapshots so the
@@ -256,12 +283,24 @@ var CodexLogAssembler = class {
   seed(snapshots) {
     this.byItemId.clear();
     this.textByItemId.clear();
+    this.passThroughSnapshots.length = 0;
+    this.snapshotOrder.length = 0;
     for (const snapshot of snapshots) {
       if (!isRecord(snapshot)) continue;
       const params = isRecord(snapshot.params) ? snapshot.params : {};
       const item = isRecord(params.item) ? params.item : null;
-      if (!item || typeof item.id !== "string") continue;
-      this.byItemId.set(item.id, clone(snapshot));
+      if (!item || typeof item.id !== "string") {
+        const method = typeof snapshot.method === "string" ? snapshot.method : void 0;
+        if (!isCodexNoiseEvent(method)) {
+          this.snapshotOrder.push({
+            kind: "passthrough",
+            index: this.passThroughSnapshots.length
+          });
+          this.passThroughSnapshots.push(clone(snapshot));
+        }
+        continue;
+      }
+      this.trackItem(item.id, clone(snapshot));
       const text = typeof item.text === "string" ? item.text : void 0;
       if (text !== void 0) {
         this.textByItemId.set(item.id, text);
@@ -288,11 +327,16 @@ var CodexLogAssembler = class {
         }
       }
     };
-    this.byItemId.set(itemId, next);
+    this.trackItem(itemId, next);
     return clone(next);
   }
   getSnapshots() {
-    return Array.from(this.byItemId.values()).map(clone);
+    const out = [];
+    for (const entry of this.snapshotOrder) {
+      const snapshot = entry.kind === "item" ? this.byItemId.get(entry.id) : this.passThroughSnapshots[entry.index];
+      if (snapshot) out.push(clone(snapshot));
+    }
+    return out;
   }
 };
 var OpenCodeLogAssembler = class {
@@ -314,6 +358,39 @@ var OpenCodeLogAssembler = class {
   childSessionToTaskCallId = /* @__PURE__ */ new Map();
   childMessageIdToTaskCallId = /* @__PURE__ */ new Map();
   messageIdToSessionId = /* @__PURE__ */ new Map();
+  // Part-less events (user `message.updated`, session lifecycle, errors).
+  // Returned by `process()` for the live channel; tracked here so
+  // `getSnapshots()` — the end-of-run persistence source — keeps them too.
+  // `message.updated` events are keyed by info.id (they re-emit on metadata
+  // updates, latest wins); everything else appends.
+  keyedPassThrough = /* @__PURE__ */ new Map();
+  passThroughSnapshots = [];
+  // First-seen chronological order across parts and passthroughs.
+  snapshotOrder = [];
+  trackPart(partId, snapshot) {
+    if (!this.byPartId.has(partId)) {
+      this.snapshotOrder.push({ kind: "part", id: partId });
+    }
+    this.byPartId.set(partId, snapshot);
+  }
+  pushPassThrough(event) {
+    const passthrough = clone(event);
+    const info = isRecord(event.properties) ? isRecord(event.properties.info) ? event.properties.info : null : null;
+    if (event.type === "message.updated" && info && typeof info.id === "string") {
+      const key = `message:${info.id}`;
+      if (!this.keyedPassThrough.has(key)) {
+        this.snapshotOrder.push({ kind: "keyed", key });
+      }
+      this.keyedPassThrough.set(key, passthrough);
+      return clone(passthrough);
+    }
+    this.snapshotOrder.push({
+      kind: "passthrough",
+      index: this.passThroughSnapshots.length
+    });
+    this.passThroughSnapshots.push(passthrough);
+    return clone(passthrough);
+  }
   process(event) {
     if (!isRecord(event)) {
       return [];
@@ -356,7 +433,7 @@ var OpenCodeLogAssembler = class {
     }
     if (type === "message.updated" && typeof info?.id === "string" && info.role === "user") {
       this.userMessageIds.add(info.id);
-      return [clone(event)];
+      return [this.pushPassThrough(event)];
     }
     const parentTaskCallId = this.resolveParentTaskCallId(
       effectiveSid,
@@ -412,10 +489,10 @@ var OpenCodeLogAssembler = class {
           );
         }
       }
-      this.byPartId.set(eventPart.id, enriched);
+      this.trackPart(eventPart.id, enriched);
       return [clone(enriched)];
     }
-    return [clone(event)];
+    return [this.pushPassThrough(event)];
   }
   seed(snapshots) {
     this.userMessageIds.clear();
@@ -426,6 +503,9 @@ var OpenCodeLogAssembler = class {
     this.childSessionToTaskCallId.clear();
     this.childMessageIdToTaskCallId.clear();
     this.messageIdToSessionId.clear();
+    this.keyedPassThrough.clear();
+    this.passThroughSnapshots.length = 0;
+    this.snapshotOrder.length = 0;
     for (const snapshot of snapshots) {
       if (!isRecord(snapshot)) continue;
       const type = typeof snapshot.type === "string" ? snapshot.type : "";
@@ -440,11 +520,16 @@ var OpenCodeLogAssembler = class {
       }
       if (type === "message.updated" && typeof info?.id === "string" && info.role === "user") {
         this.userMessageIds.add(info.id);
+        this.pushPassThrough(snapshot);
         continue;
       }
       const part = isRecord(properties.part) ? properties.part : isRecord(snapshot.part) ? snapshot.part : null;
+      if (!part || typeof part.id !== "string") {
+        this.pushPassThrough(snapshot);
+        continue;
+      }
       if (part && typeof part.id === "string") {
-        this.byPartId.set(part.id, clone(snapshot));
+        this.trackPart(part.id, clone(snapshot));
         if (typeof part.text === "string") {
           this.textByPartId.set(part.id, part.text);
         }
@@ -538,13 +623,27 @@ var OpenCodeLogAssembler = class {
         part
       }
     };
-    this.byPartId.set(partId, next);
+    this.trackPart(partId, next);
     return clone(next);
   }
   getSnapshots() {
-    return Array.from(this.byPartId.values()).map(clone);
+    const out = [];
+    for (const entry of this.snapshotOrder) {
+      const snapshot = entry.kind === "part" ? this.byPartId.get(entry.id) : entry.kind === "keyed" ? this.keyedPassThrough.get(entry.key) : this.passThroughSnapshots[entry.index];
+      if (snapshot) out.push(clone(snapshot));
+    }
+    return out;
   }
 };
+function isClaudeNoiseEvent(event) {
+  const type = typeof event.type === "string" ? event.type : "";
+  if (type === "rate_limit_event" || type === "tool_progress") return true;
+  if (type === "system") {
+    const sub = typeof event.subtype === "string" ? event.subtype : "";
+    return sub === "status" || sub === "hook_started" || sub === "hook_response" || sub === "hook_progress" || sub === "api_retry" || sub === "auth_status";
+  }
+  return false;
+}
 var ClaudeCodeLogAssembler = class {
   currentMessageId = null;
   textByMessageId = /* @__PURE__ */ new Map();
@@ -565,6 +664,12 @@ var ClaudeCodeLogAssembler = class {
   // insertion order so `getSnapshots()` returns the full trace, not just the
   // deduped assistant messages.
   passThroughSnapshots = [];
+  // First-seen chronological order of everything `getSnapshots()` returns:
+  // messages anchor at the position of their first event (message_start or
+  // first assistant block) and passthroughs at arrival. Without this the
+  // persisted trace would list every message first and every tool_result /
+  // system event after, scrambling replay order for sequential consumers.
+  snapshotOrder = [];
   process(event) {
     if (!isRecord(event)) return [];
     const type = typeof event.type === "string" ? event.type : "";
@@ -606,24 +711,32 @@ var ClaudeCodeLogAssembler = class {
       const message = isRecord(event.message) ? event.message : null;
       const id = message && typeof message.id === "string" ? message.id : null;
       if (!id || !message) {
-        const passthrough2 = clone(event);
-        this.passThroughSnapshots.push(passthrough2);
-        return [clone(passthrough2)];
+        return [this.pushPassThrough(event)];
       }
       this.setParentToolUseId(id, event);
       const final = extractClaudeAssistantContent(message);
-      this.textByMessageId.set(id, final.text);
-      if (final.thinking) {
+      const streamedText = this.textByMessageId.get(id) ?? "";
+      if (final.text.length > streamedText.length) {
+        this.textByMessageId.set(id, final.text);
+      }
+      const streamedThinking = this.thinkingByMessageId.get(id) ?? "";
+      if (final.thinking.length > streamedThinking.length) {
         this.thinkingByMessageId.set(id, final.thinking);
       }
       this.mergeExtraBlocks(id, final.extraBlocks);
-      const snapshot = this.upsertMessage(id);
-      this.currentMessageId = null;
-      return [snapshot];
+      return [this.upsertMessage(id)];
     }
+    if (isClaudeNoiseEvent(event)) return [];
+    return [this.pushPassThrough(event)];
+  }
+  pushPassThrough(event) {
     const passthrough = clone(event);
+    this.snapshotOrder.push({
+      kind: "passthrough",
+      index: this.passThroughSnapshots.length
+    });
     this.passThroughSnapshots.push(passthrough);
-    return [clone(passthrough)];
+    return clone(passthrough);
   }
   seed(snapshots) {
     this.currentMessageId = null;
@@ -633,15 +746,26 @@ var ClaudeCodeLogAssembler = class {
     this.byMessageId.clear();
     this.extraBlocksByMessageId.clear();
     this.passThroughSnapshots.length = 0;
+    this.snapshotOrder.length = 0;
     for (const snapshot of snapshots) {
       if (!isRecord(snapshot)) continue;
       if (snapshot.type !== "message.updated") {
-        this.passThroughSnapshots.push(clone(snapshot));
+        if (!isClaudeNoiseEvent(snapshot)) {
+          this.snapshotOrder.push({
+            kind: "passthrough",
+            index: this.passThroughSnapshots.length
+          });
+          this.passThroughSnapshots.push(clone(snapshot));
+        }
         continue;
       }
       const messageId = typeof snapshot.messageId === "string" ? snapshot.messageId : null;
       if (!messageId) continue;
+      if (!this.byMessageId.has(messageId)) {
+        this.snapshotOrder.push({ kind: "message", id: messageId });
+      }
       this.byMessageId.set(messageId, clone(snapshot));
+      this.currentMessageId = messageId;
       const parentToolUseId = typeof snapshot.parent_tool_use_id === "string" ? snapshot.parent_tool_use_id : null;
       this.parentToolUseIdByMessageId.set(messageId, parentToolUseId);
       const message = isRecord(snapshot.message) ? snapshot.message : null;
@@ -707,13 +831,18 @@ var ClaudeCodeLogAssembler = class {
         content
       }
     };
+    if (!this.byMessageId.has(messageId)) {
+      this.snapshotOrder.push({ kind: "message", id: messageId });
+    }
     this.byMessageId.set(messageId, next);
     return clone(next);
   }
   getSnapshots() {
     const out = [];
-    for (const snapshot of this.byMessageId.values()) out.push(clone(snapshot));
-    for (const snapshot of this.passThroughSnapshots) out.push(clone(snapshot));
+    for (const entry of this.snapshotOrder) {
+      const snapshot = entry.kind === "message" ? this.byMessageId.get(entry.id) : this.passThroughSnapshots[entry.index];
+      if (snapshot) out.push(clone(snapshot));
+    }
     return out;
   }
 };

package/dist/events/index.js

@@ -4,7 +4,7 @@ import {
   normalizeRawAgentEvent,
   toAISDKEvent,
   toAISDKStream
-} from "../chunk-2DH5OVG4.js";
+} from "../chunk-775FIGGL.js";
 import "../chunk-GOFJNFAD.js";
 export {
   ProviderLogAssembler,

package/dist/index.js

@@ -2,14 +2,14 @@ import {
   Agent,
   agentboxRoot,
   getAgentLayout
-} from "./chunk-75KPGNTE.js";
+} from "./chunk-2IHQY3WC.js";
 import {
   ProviderLogAssembler,
   createNormalizedEvent,
   normalizeRawAgentEvent,
   toAISDKEvent,
   toAISDKStream
-} from "./chunk-2DH5OVG4.js";
+} from "./chunk-775FIGGL.js";
 import {
   Sandbox,
   SandboxAdapter,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentbox-sdk",
-  "version": "0.1.317",
+  "version": "0.1.319",
   "description": "Swappable coding agents and sandbox providers for Bun and TypeScript.",
   "license": "MIT",
   "repository": {