mixdog 1.2.5 → 1.2.6

package/src/runtime/agent/orchestrator/mcp/child-tree.mjs

@@ -9,6 +9,7 @@
 // tree (taskkill /T /F on Windows, SIGTERM->SIGKILL of every descendant on
 // POSIX). No external dependencies.
 import { spawn } from 'node:child_process';
+import { runProcessOffThread } from '../../../shared/process-runner.mjs';
 import { detachedSpawnOpts } from '../../../shared/spawn-flags.mjs';
 
 const isWin = process.platform === 'win32';
@@ -44,54 +45,26 @@ function transportPid(transport) {
  *  settled, so enumerators never pile up whatever this value is. */
 export const ENUMERATION_DEADLINE_MS = 20_000;
 
-// Spawn a helper command and resolve its stdout (empty string on any error).
-// `timeoutMs` > 0: past the deadline the helper is killed (Node reaps it on
-// exit) and the call settles at once instead of waiting for it.
-function run(cmd, args, { strict = false, timeoutMs = 0 } = {}) {
-  return new Promise((resolve, reject) => {
-    let out = '';
-    let cp;
-    let timer = null;
-    let settled = false;
-    const settle = (finish) => {
-      if (settled) return;
-      settled = true;
-      if (timer) clearTimeout(timer);
-      finish();
-    };
-    try {
-      cp = spawn(cmd, args, { windowsHide: true });
-    } catch (error) {
-      if (strict) {
-        reject(error);
-        return;
-      }
-      resolve('');
-      return;
-    }
-    cp.stdout?.on('data', (d) => {
-      out += String(d);
-    });
-    cp.on('error', (error) => settle(() => (strict ? reject(error) : resolve(out))));
-    cp.on('close', (code) =>
-      settle(() => (strict && code !== 0 ? reject(new Error(`Process enumeration failed (${code}).`)) : resolve(out)))
-    );
-    if (timeoutMs > 0) {
-      timer = setTimeout(() => {
-        try {
-          cp.kill('SIGKILL');
-        } catch {
-          /* already gone */
-        }
-        cp.stdout?.destroy?.();
-        cp.stderr?.destroy?.();
-        settle(() =>
-          strict ? reject(new Error(`Process enumeration timed out after ${timeoutMs} ms.`)) : resolve('')
-        );
-      }, timeoutMs);
-      timer.unref?.();
+// Output bound of one helper command: a process table is tens of KB.
+const HELPER_MAX_BYTES = 64 * 1024 * 1024;
+
+// Run a helper command off the event loop (process-runner.mjs: under load one
+// PowerShell start blocked the daemon's loop for seconds) and resolve its
+// stdout. Past `timeoutMs` (default ENUMERATION_DEADLINE_MS) the helper is
+// killed and the call settles. Strict: a failed, non-zero or timed-out run
+// rejects; otherwise it resolves '' (non-zero exits keep their stdout).
+function run(cmd, args, { strict = false, timeoutMs = ENUMERATION_DEADLINE_MS } = {}) {
+  return runProcessOffThread(cmd, args, { timeoutMs, maxBytes: HELPER_MAX_BYTES }).then(
+    ({ code, stdout }) => {
+      if (strict && code !== 0) throw new Error(`Process enumeration failed (${code}).`);
+      return stdout;
+    },
+    (error) => {
+      if (!strict) return '';
+      if (error?.code === 'ETIMEDOUT') throw new Error(`Process enumeration timed out after ${timeoutMs} ms.`);
+      throw error;
     }
-  });
+  );
 }
 
 // Snapshot the whole process table once: parent map + a per-pid identity
@@ -114,21 +87,25 @@ async function enumerate({ strict = false } = {}) {
         ],
         { strict, timeoutMs: ENUMERATION_DEADLINE_MS }
       )
-    : await run('ps', ['-A', '-o', 'pid=,ppid=,pgid=,comm=,lstart='], {
+    : await run('ps', ['-A', '-o', 'pid=,ppid=,pgid=,stat=,comm=,lstart='], {
         strict,
         timeoutMs: ENUMERATION_DEADLINE_MS,
       });
-  const row = isWin ? /^(\d+)\s+(\d+)\s+()(\S+)(?:\s+(.+))?$/ : /^(\d+)\s+(\d+)\s+(\d+)\s+(\S+)(?:\s+(.+))?$/;
+  const row = isWin ? /^(\d+)\s+(\d+)\s+()()(\S+)(?:\s+(.+))?$/ : /^(\d+)\s+(\d+)\s+(\d+)\s+(\S+)\s+(\S+)(?:\s+(.+))?$/;
   for (const line of out.split(/\r?\n/)) {
     const m = line.trim().match(row);
     if (!m) continue;
+    // A zombie runs nothing and holds no port or file; it only waits to be
+    // reaped (forever under an init that does not reap, e.g. a container
+    // without one). Counting it alive would hold a dead tree as running.
+    if (m[4].startsWith('Z')) continue;
     const pid = Number(m[1]);
     const ppid = Number(m[2]);
-    const token = (m[5] || '').trim() || null;
+    const token = (m[6] || '').trim() || null;
     if (!childrenOf.has(ppid)) childrenOf.set(ppid, []);
     childrenOf.get(ppid).push(pid);
     tokenOf.set(pid, token);
-    nameOf.set(pid, m[4]);
+    nameOf.set(pid, m[5]);
     if (m[3]) pgidOf.set(pid, Number(m[3]));
   }
   if (strict && !nameOf.has(process.pid)) throw new Error('The process snapshot could not be verified.');
@@ -142,17 +119,33 @@ async function enumerate({ strict = false } = {}) {
  *  `shared: true` (pre-kill captures) joins a read already in flight, so many
  *  jobs promoted together do not each spawn an enumerator; a capture taken
  *  while its root runs is valid whenever that read began. An observation after
- *  a kill never shares: a read that began before the kill would report the
- *  killed tree alive and defer the confirmation by a whole re-check. */
+ *  a kill or exit must see a table taken AFTER it asked: a read that began
+ *  before the kill would report the killed tree alive and defer the
+ *  confirmation by a whole re-check. Such a caller starts a read when none
+ *  runs, else joins the one queued to begin when the running read settles —
+ *  every observer asking meanwhile shares it. At most one enumerator runs at
+ *  a time, however many shells settle or watch at once (each one is a
+ *  PowerShell process on Windows; one per settle and watch pass compounded
+ *  machine load into multi-second daemon stalls). */
 let tableInFlight = null;
+let nextTable = null;
+function startTableRead() {
+  const read = enumerate({ strict: true }).finally(() => {
+    if (tableInFlight === read) tableInFlight = null;
+  });
+  tableInFlight = read;
+  return read;
+}
 export function readProcessTable({ shared = false } = {}) {
-  if (!shared) return enumerate({ strict: true });
-  if (!tableInFlight) {
-    tableInFlight = enumerate({ strict: true }).finally(() => {
-      tableInFlight = null;
-    });
-  }
-  return tableInFlight;
+  if (shared && tableInFlight) return tableInFlight;
+  if (nextTable) return nextTable;
+  if (!tableInFlight) return startTableRead();
+  const settled = () => {};
+  nextTable = tableInFlight.then(settled, settled).then(() => {
+    nextTable = null;
+    return startTableRead();
+  });
+  return nextTable;
 }
 
 // Walk every descendant pid of rootPid (excludes rootPid).

package/src/runtime/agent/orchestrator/mcp/client.mjs

@@ -14,7 +14,7 @@ import { basename, join, resolve } from 'node:path';
 import { pathToFileURL } from 'node:url';
 import { tmpdir } from 'node:os';
 import { createHash, randomUUID } from 'node:crypto';
-import { buildSmartReadTruncationMarker, smartReadTruncate } from '../tools/builtin/read-formatting.mjs';
+import { smartReadTruncate } from '../tools/builtin/read-formatting.mjs';
 import { shutdownStdioChild, killStdioChildTreeFast } from './child-tree.mjs';
 import { makeToolEnvelope, normalizeToolEnvelope } from '../session/tool-envelope.mjs';
 import { classifyResultKind } from '../session/result-classification.mjs';
@@ -308,7 +308,11 @@ function callAdmissionFor(server) {
   const cfg = server?.cfg || {};
   gate = createOwnerFairGate({
     name: `MCP ${server.name}`,
-    activeMax: positiveInt(cfg.maxConcurrency ?? cfg.max_concurrency ?? process.env.MIXDOG_MCP_MAX_INFLIGHT, 8),
+    // JSON-RPC multiplexes requests by id over one transport, so the client
+    // imposes no in-flight cap of its own; a server that needs one declares
+    // it (maxConcurrency) or the operator sets MIXDOG_MCP_MAX_INFLIGHT.
+    activeMax:
+      positiveInt(cfg.maxConcurrency ?? cfg.max_concurrency ?? process.env.MIXDOG_MCP_MAX_INFLIGHT, null) ?? Infinity,
     queueMax: positiveInt(cfg.maxQueue ?? cfg.max_queue ?? process.env.MIXDOG_MCP_MAX_QUEUE, 256),
     minOwnerQueue: 8,
     waitTimeoutMs: positiveInt(
@@ -1037,7 +1041,7 @@ function capMcpOutputParts(content) {
   const s = typeof content === 'string' ? content : String(content ?? '');
   const bodyBytes = Buffer.byteLength(s, 'utf8');
   const bodyLines = countTextLines(s);
-  const { text, truncated } = smartReadTruncate(s, bodyLines, bodyBytes);
+  const { text, truncated, marker } = smartReadTruncate(s, bodyLines, bodyBytes);
   if (!truncated) return { text, spillNote: '', truncated: false };
   // Spill the full body to a tmp file so the caller can recover content
   // elided by the head/tail cap.
@@ -1056,7 +1060,6 @@ function capMcpOutputParts(content) {
     /* spill best-effort */
   }
   const spillNote = spillPath ? `\n\n... [full output spilled to ${spillPath}] ...` : '';
-  const marker = buildSmartReadTruncationMarker(bodyLines, bodyBytes);
   const split = text.indexOf(`\n${marker}\n`);
   return {
     text,

package/src/runtime/agent/orchestrator/mcp/oauth-callback.mjs

@@ -70,8 +70,7 @@ export function answerOAuthCallback(req, res, { redirectUrl, state, finish, serv
     });
     res.end(html);
   };
-  const invalid = () =>
-    page(400, oauthErrorHtml('This sign-in link is invalid or has expired.', 'Start the sign-in again from Mixdog.'));
+  const invalid = () => page(400, oauthErrorHtml('This sign-in link is invalid or has expired.'));
   let target;
   try {
     target = new URL(req.url || '/', redirectUrl);
@@ -94,7 +93,7 @@ export function answerOAuthCallback(req, res, { redirectUrl, state, finish, serv
   const server = serverName || 'the MCP server';
   if (target.searchParams.has('error')) {
     // The authorization server's error text is never reflected.
-    page(400, oauthErrorHtml(`Sign-in to ${server} was not completed.`, 'Start the sign-in again from Mixdog.'));
+    page(400, oauthErrorHtml(`Sign-in to ${server} was not completed.`));
     finish(undefined);
     return;
   }

package/src/runtime/agent/orchestrator/providers/account-pool.mjs

@@ -378,14 +378,21 @@ function poolSend(providerName, account) {
     // remaining wait budget is waited out; otherwise the send fails as before.
     const waitOrThrow = async (error, ids) => {
       const { rows, now, all } = exhaustion(ids);
-      const wait = all ? null : earliestCooldownMs(rows, now);
-      if (wait == null || waitedMs + wait > waitBoundMs(ids)) throw markExhausted(error, ids);
+      const bound = waitBoundMs(ids);
+      // Persisting a short cooldown can outlast its deadline. Release only
+      // attempts cooled by this send, and only under an enabled wait policy.
+      const expired = bound > 0 && rows.some((row) => cooled.has(row.id) && !(Number(row.blockedUntil) > now));
+      const wait = all ? null : expired ? 0 : earliestCooldownMs(rows, now);
+      if (wait == null || waitedMs + wait > bound) throw markExhausted(error, ids);
       options.onStageChange?.('reconnecting', {
         message: `Rate limited — every account is cooling down; retrying in ${Math.ceil(wait / 1000)}s`,
         reason: 'rate_limited',
         waitMs: wait,
         retryAt: now + wait,
       });
+      // A zero-duration sleep does not check cancellation, including on the
+      // final allowed send when no next loop iteration will check it either.
+      options.signal?.throwIfAborted();
       await sleepWithAbort(wait, options.signal);
       waitedMs += wait;
       const lifted = Date.now();

package/src/runtime/agent/orchestrator/providers/anthropic-oauth-credentials.mjs

@@ -25,6 +25,7 @@ import {
   scrubOAuthSecrets,
 } from './lib/oauth-token-utils.mjs';
 import { createOAuthPkce, parseOAuthCodeInput } from './lib/oauth-pkce.mjs';
+import { OAUTH_PAGE_CONTENT_TYPE, oauthErrorHtml, oauthSuccessHtml } from './lib/oauth-page.mjs';
 
 const SIGN_IN_EXPIRED_PREFIX = 'Anthropic sign-in expired. Sign in again from Providers.';
 
@@ -66,8 +67,6 @@ const OAUTH_CALLBACK_PATH = '/callback';
 const OAUTH_REDIRECT_URI = `http://${OAUTH_CALLBACK_HOST}:${OAUTH_CALLBACK_PORT}${OAUTH_CALLBACK_PATH}`;
 const OAUTH_MANUAL_REDIRECT_URI =
   process.env.ANTHROPIC_OAUTH_MANUAL_REDIRECT_URI || 'https://platform.claude.com/oauth/code/callback';
-const OAUTH_SUCCESS_REDIRECT_URL =
-  process.env.ANTHROPIC_OAUTH_SUCCESS_REDIRECT_URL || 'https://platform.claude.com/oauth/code/success?app=claude-code';
 const OAUTH_LOGIN_TIMEOUT_MS = 5 * 60_000;
 const OAUTH_TOKEN_TIMEOUT_MS = 30_000;
 
@@ -110,7 +109,7 @@ function _loadCredentialsFile(path) {
 }
 
 // The token endpoint names the signed-in account next to the tokens.
-export function identityFromTokenResponse(json) {
+function identityFromTokenResponse(json) {
   return normalizeAccountIdentity({
     id: json?.account?.uuid,
     email: json?.account?.email_address,
@@ -570,9 +569,11 @@ function _parseOAuthCodeInput(input) {
   return parseOAuthCodeInput(input, { allowHashState: true });
 }
 
-async function exchangeAuthorizationCode({ pkce, code, state, redirectUri }) {
+async function exchangeAuthorizationCode({ pkce, code, state, redirectUri, signal = null }) {
+  signal?.throwIfAborted();
   const cleanCode = String(code || '').trim();
   if (!cleanCode) throw new Error('[anthropic-oauth] authorization code is required');
+  const timeoutSignal = AbortSignal.timeout(OAUTH_TOKEN_TIMEOUT_MS);
   const tokenRes = await fetch(TOKEN_URL, {
     method: 'POST',
     headers: tokenEndpointHeaders(),
@@ -585,7 +586,7 @@ async function exchangeAuthorizationCode({ pkce, code, state, redirectUri }) {
       state,
     }),
     redirect: 'error',
-    signal: AbortSignal.timeout(OAUTH_TOKEN_TIMEOUT_MS),
+    signal: signal ? AbortSignal.any([signal, timeoutSignal]) : timeoutSignal,
     dispatcher: getLlmDispatcher(),
   });
   if (!tokenRes.ok) {
@@ -605,6 +606,8 @@ async function exchangeAuthorizationCode({ pkce, code, state, redirectUri }) {
   const expiresAt = expiresAtFromTokenResponse(json);
   const scopes = _oauthParseScopeField(json?.scope);
   const identity = identityFromTokenResponse(json);
+  // A cancelled login never stores the account it was exchanging.
+  signal?.throwIfAborted();
   const credPath = _oauthCredentialsWritePath();
   const raw = _updateCredentialsFile(credPath, (current) => {
     const base = current && typeof current === 'object' ? current : {};
@@ -664,14 +667,33 @@ export async function beginOAuthLogin({ openBrowserFn = null, openBrowser = true
     }
   };
 
+  const controller = new AbortController();
   let server = null;
   let timeout = null;
   let finish = null;
+  let exchangePromise = null;
+  // Browser and manual callbacks share one exchange: an authorization code is
+  // spent once, and a duplicate joins the first instead of failing the login.
+  const acceptCode = (code, redirectUri) => {
+    if (exchangePromise) return exchangePromise;
+    controller.signal.throwIfAborted();
+    // The browser deadline ends when a code arrives; the exchange has its own.
+    if (timeout) clearTimeout(timeout);
+    timeout = null;
+    exchangePromise = exchangeAuthorizationCode({ pkce, code, state, redirectUri, signal: controller.signal });
+    exchangePromise.then(
+      (tokens) => finish(tokens),
+      (error) => finish(null, error instanceof Error ? error : new Error(String(error)))
+    );
+    return exchangePromise;
+  };
   const waitForCallback = new Promise((resolve, reject) => {
     let settled = false;
     finish = (value, error = null) => {
       if (settled) return;
       settled = true;
+      // Work arriving after the login settled (or was cancelled) is rejected.
+      controller.abort();
       if (timeout) clearTimeout(timeout);
       try {
         server?.close();
@@ -691,20 +713,20 @@ export async function beginOAuthLogin({ openBrowserFn = null, openBrowser = true
       const code = u.searchParams.get('code');
       if (!code || u.searchParams.get('state') !== state) {
         // Reject this request only; the valid callback may still arrive.
-        res.writeHead(400);
-        res.end('Invalid');
+        res.writeHead(400, { 'Content-Type': OAUTH_PAGE_CONTENT_TYPE });
+        res.end(oauthErrorHtml('The sign-in callback was invalid or did not match this login.'));
         return;
       }
+      // The login settles (and its server closes) before this answer is sent,
+      // so the connection must not stay open to the closed login's handler.
       try {
-        const tokens = await exchangeAuthorizationCode({ pkce, code, state, redirectUri: OAUTH_REDIRECT_URI });
-        res.writeHead(302, { Location: OAUTH_SUCCESS_REDIRECT_URL });
-        res.end();
-        finish(tokens);
-      } catch (err) {
-        const error = err instanceof Error ? err : new Error(String(err));
-        res.writeHead(500, { 'Content-Type': 'text/plain; charset=utf-8' });
-        res.end(`Claude login failed: ${error.message}`);
-        finish(null, error);
+        await acceptCode(code, OAUTH_REDIRECT_URI);
+        res.writeHead(200, { 'Content-Type': OAUTH_PAGE_CONTENT_TYPE, Connection: 'close' });
+        res.end(oauthSuccessHtml('Claude'));
+      } catch {
+        // The shared exchange reports its error through waitForCallback.
+        res.writeHead(500, { 'Content-Type': OAUTH_PAGE_CONTENT_TYPE, Connection: 'close' });
+        res.end(oauthErrorHtml('Claude could not complete the token exchange.'));
       }
     });
     timeout = setTimeout(() => finish(null), OAUTH_LOGIN_TIMEOUT_MS);
@@ -730,10 +752,9 @@ export async function beginOAuthLogin({ openBrowserFn = null, openBrowser = true
     completeCode: async (input) => {
       const parsed = _parseOAuthCodeInput(input);
       if (parsed.state && parsed.state !== state) throw new Error('[anthropic-oauth] OAuth state mismatch');
+      if (!String(parsed.code || '').trim()) throw new Error('[anthropic-oauth] authorization code is required');
       const redirectUri = parsed.redirectUri || (parsed.state ? OAUTH_MANUAL_REDIRECT_URI : OAUTH_REDIRECT_URI);
-      const tokens = await exchangeAuthorizationCode({ pkce, code: parsed.code, state, redirectUri });
-      finish?.(tokens);
-      return tokens;
+      return await acceptCode(parsed.code, redirectUri);
     },
     cancel: () => {
       finish?.(null);

package/src/runtime/agent/orchestrator/providers/anthropic-oauth.mjs

@@ -448,7 +448,8 @@ export class AnthropicOAuthProvider {
     // a hard 400. Pairing here closes the gap regardless of caller.
     messages = sanitizeToolPairs(messages);
     const opts = sendOpts || {};
-    const { onStageChange, onStreamDelta, onToolCall, onTextDelta, onTextReset } = streamCallbacks(opts);
+    const { onStageChange, onStreamDelta, onToolCall, onTextDelta, onTextReset, onStreamItemStart } =
+      streamCallbacks(opts);
     const externalSignal = opts.signal || null;
     // Test seam: lets the retry harness drive stream outcomes without a
     // live OAuth session.
@@ -610,7 +611,7 @@ export class AnthropicOAuthProvider {
             midState,
             onTextDelta,
             knownToolNames,
-            { relayProgressUpdates: body.thinking?.display === 'updates' }
+            { relayProgressUpdates: body.thinking?.display === 'updates', onStreamItemStart }
           );
           try {
             controller?.abort?.('Anthropic SSE complete');

package/src/runtime/agent/orchestrator/providers/anthropic-sse-turn/turn-events/content-block-start.mjs

@@ -8,6 +8,7 @@ import {
   NATIVE_SERVER_TOOL_RESULT_BLOCK_TYPES,
 } from '../../lib/anthropic-native-blocks.mjs';
 import { parseAnthropicFallbackBlock } from '../../anthropic-server-fallback.mjs';
+import { reportStreamItemStart } from '../../lib/send-callbacks.mjs';
 
 // Detach the provider payload from the parser's event object without altering
 // any field (opaque server-tool result payloads must round-trip byte-exact).
@@ -19,7 +20,7 @@ function cloneNativeBlock(block) {
   }
 }
 
-export function createContentBlockStart({ turn, blocks, state, progress, seedText }) {
+export function createContentBlockStart({ turn, blocks, state, progress, seedText, onStreamItemStart }) {
   const seedThinkingBlock = (index, block) => {
     if (block.type === 'redacted_thinking') {
       // Opaque redacted payload: real reasoning content, exposed as a block.
@@ -59,6 +60,8 @@ export function createContentBlockStart({ turn, blocks, state, progress, seedTex
         name: block.name || '',
         inputJson: '',
       });
+      // The call opened; its input still streams before onToolCall.
+      reportStreamItemStart(onStreamItemStart, { kind: 'tool' });
     }
     if (block?.type === 'text') {
       // Seed the ordered text slot. An empty block still needs its slot (it

package/src/runtime/agent/orchestrator/providers/anthropic-sse-turn/turn-events.mjs

@@ -19,6 +19,7 @@ export function createTurnEvents({
   onToolCall,
   relayProgressUpdates,
   labels,
+  onStreamItemStart,
 }) {
   const { onMessageStart, onMessageDelta, onMessageStop } = createMessageEvents({ turn, blocks, state });
   const onContentBlockDelta = createContentBlockDelta({
@@ -38,6 +39,7 @@ export function createTurnEvents({
       state,
       progress,
       seedText: onContentBlockDelta.seedText,
+      onStreamItemStart,
     }),
     onContentBlockDelta,
     onContentBlockStop: createContentBlockStop({ turn, blocks, state, leak, progress, onToolCall, labels }),

package/src/runtime/agent/orchestrator/providers/anthropic-sse-turn.mjs

@@ -24,6 +24,7 @@ import { OAUTH_STREAM_LABELS } from './lib/anthropic-stream-labels.mjs';
  * @param {Iterable<string>} [deps.knownToolNames]
  * @param {boolean} [deps.relayProgressUpdates]  request used thinking.display "updates"
  * @param {{ display: string, tag: string }} [deps.labels]  provider name for errors and stderr lines
+ * @param {(detail: object) => void} [deps.onStreamItemStart]  a client tool_use block opened
  */
 export function createAnthropicSseTurn({
   state,
@@ -33,6 +34,7 @@ export function createAnthropicSseTurn({
   knownToolNames,
   relayProgressUpdates = false,
   labels = OAUTH_STREAM_LABELS,
+  onStreamItemStart = null,
 }) {
   const progress = (kind) => {
     try {
@@ -64,6 +66,7 @@ export function createAnthropicSseTurn({
     onToolCall,
     relayProgressUpdates,
     labels,
+    onStreamItemStart,
   });
   const outcome = createTurnOutcome({ turn, blocks, state, labels });
 

package/src/runtime/agent/orchestrator/providers/anthropic-sse.mjs

@@ -186,7 +186,7 @@ export async function parseSSEStream(
   state,
   onTextDelta,
   knownToolNames,
-  { relayProgressUpdates = false, labels = OAUTH_STREAM_LABELS } = {}
+  { relayProgressUpdates = false, labels = OAUTH_STREAM_LABELS, onStreamItemStart = null } = {}
 ) {
   // Anthropic/Claude parity: every received SSE byte proves transport
   // activity, including comment and named ping keepalives. Content kinds
@@ -208,6 +208,7 @@ export async function parseSSEStream(
     knownToolNames,
     relayProgressUpdates,
     labels,
+    onStreamItemStart,
   });
   const watchdogs = createAnthropicSseWatchdogs({
     state,

package/src/runtime/agent/orchestrator/providers/anthropic.mjs

@@ -162,7 +162,8 @@ export class AnthropicProvider {
     });
     this.fastModeBetaHeaderLatched = fastModeLatched;
 
-    const { onStageChange, onStreamDelta, onToolCall, onTextDelta, onTextReset } = streamCallbacks(opts);
+    const { onStageChange, onStreamDelta, onToolCall, onTextDelta, onTextReset, onStreamItemStart } =
+      streamCallbacks(opts);
 
     // No absolute wall-clock cap on streaming generation: a stream still
     // emitting SSE deltas must not be killed by a fixed total-lifetime timer.
@@ -288,6 +289,7 @@ export class AnthropicProvider {
             {
               relayProgressUpdates: params.thinking?.display === 'updates',
               labels: { display: 'Anthropic', tag: this.name },
+              onStreamItemStart,
             }
           );
           try {

package/src/runtime/agent/orchestrator/providers/antigravity-oauth-login.mjs

@@ -36,8 +36,7 @@ import {
 
 const ONBOARD_INTERVAL_MS = 1_000;
 const CALLBACK_FAILURE_HTML = oauthErrorHtml(
-  'Antigravity sign-in was not completed.',
-  'Return to Mixdog for the error details and any account verification link.'
+  'Antigravity sign-in was not completed. Return to Mixdog for the error details and any account verification link.'
 );
 
 function extractProjectId(payload) {