claude-code-rust 0.14.1 → 0.14.3

package/agent-sdk/dist/bridge/mcp.js

@@ -1,8 +1,9 @@
 import { emitMcpOperationError, slashError, writeEvent } from "./events.js";
 import { bridgeLogger, LOG_TARGETS } from "./logger.js";
 import { bridgeMcpServersToSdk, mapMcpServerStatus, summarizeMcpServersForDiagnostics, } from "./mcp_metadata.js";
+import { authenticateMcpServer, clearMcpServerAuth, detectMcpAuthCapabilities, submitMcpOAuthCallbackUrl, } from "./mcp_auth_adapter.js";
+import { runMcpAuthMonitor, } from "./mcp_monitor.js";
 export const MCP_STALE_STATUS_REVALIDATION_COOLDOWN_MS = 30_000;
-const knownConnectedMcpServers = new Set();
 function logMcpSuccess(eventName, message, sessionId, requestId, fields) {
     bridgeLogger.info({
         target: LOG_TARGETS.BRIDGE_MCP,
@@ -28,9 +29,6 @@ function logMcpFailure(eventName, message, sessionId, errorMessage, requestId, f
         },
     });
 }
-function queryWithMcpAuth(session) {
-    return session.query;
-}
 function mapMcpSetServersResult(result) {
     if (!result || typeof result !== "object" || Array.isArray(result)) {
         return { added: [], removed: [], errors: {} };
@@ -47,41 +45,6 @@ function mapMcpSetServersResult(result) {
         : {};
     return { added, removed, errors };
 }
-async function callMcpAuthMethod(session, methodName, args) {
-    const query = queryWithMcpAuth(session);
-    switch (methodName) {
-        case "mcpAuthenticate":
-            if (typeof query.mcpAuthenticate !== "function") {
-                throw new Error("installed SDK does not support mcpAuthenticate");
-            }
-            return await query.mcpAuthenticate(args[0] ?? "");
-        case "mcpClearAuth":
-            if (typeof query.mcpClearAuth !== "function") {
-                throw new Error("installed SDK does not support mcpClearAuth");
-            }
-            return await query.mcpClearAuth(args[0] ?? "");
-        case "mcpSubmitOAuthCallbackUrl":
-            if (typeof query.mcpSubmitOAuthCallbackUrl !== "function") {
-                throw new Error("installed SDK does not support mcpSubmitOAuthCallbackUrl");
-            }
-            return await query.mcpSubmitOAuthCallbackUrl(args[0] ?? "", args[1] ?? "");
-    }
-}
-function extractMcpAuthRedirect(serverName, value) {
-    if (!value || typeof value !== "object") {
-        return null;
-    }
-    const authUrl = Reflect.get(value, "authUrl");
-    if (typeof authUrl !== "string" || authUrl.trim().length === 0) {
-        return null;
-    }
-    const requiresUserAction = Reflect.get(value, "requiresUserAction");
-    return {
-        server_name: serverName,
-        auth_url: authUrl,
-        requires_user_action: requiresUserAction === true,
-    };
-}
 function emitMcpCommandError(sessionId, operation, message, requestId, serverName) {
     emitMcpOperationError(sessionId, {
         ...(serverName ? { server_name: serverName } : {}),
@@ -90,9 +53,10 @@ function emitMcpCommandError(sessionId, operation, message, requestId, serverNam
     }, requestId);
 }
 export async function emitMcpSnapshotEvent(session, requestId, source = "mcp_status") {
-    const servers = await session.query.mcpServerStatus();
-    let mapped = servers.map(mapMcpServerStatus);
-    mapped = await reconcileSuspiciousMcpStatuses(session, mapped);
+    const mapped = await loadReconciledMcpStatuses(session);
+    if (!mapped) {
+        return [];
+    }
     return emitMcpSnapshotFromMappedStatuses(session, mapped, source, requestId);
 }
 export function emitMcpSnapshotFromStatuses(session, servers, source, requestId) {
@@ -104,7 +68,7 @@ export async function emitReconciledMcpSnapshotFromStatuses(session, servers, so
     return emitMcpSnapshotFromMappedStatuses(session, mapped, source, requestId);
 }
 function emitMcpSnapshotFromMappedStatuses(session, mapped, source, requestId) {
-    rememberKnownConnectedMcpServers(mapped);
+    rememberKnownConnectedMcpServers(session, mapped);
     logMcpSuccess("mcp_snapshot_emitted", "MCP snapshot emitted", session.sessionId, requestId, {
         source,
         server_count: mapped.length,
@@ -115,6 +79,7 @@ function emitMcpSnapshotFromMappedStatuses(session, mapped, source, requestId) {
         session_id: session.sessionId,
         source,
         servers: mapped,
+        auth_capabilities: detectMcpAuthCapabilities(session.query),
     }, requestId);
     return mapped;
 }
@@ -132,23 +97,33 @@ export function staleMcpAuthCandidates(servers, knownConnectedServerNames, lastR
     })
         .map((server) => server.name);
 }
-function rememberKnownConnectedMcpServers(servers) {
+function rememberKnownConnectedMcpServers(session, servers) {
     for (const server of servers) {
         if (server.status === "connected") {
-            knownConnectedMcpServers.add(server.name);
+            session.knownConnectedMcpServers.add(server.name);
         }
     }
 }
-function forgetKnownConnectedMcpServer(serverName) {
-    knownConnectedMcpServers.delete(serverName);
+function forgetKnownConnectedMcpServer(session, serverName) {
+    session.knownConnectedMcpServers.delete(serverName);
 }
-async function reconcileSuspiciousMcpStatuses(session, servers) {
-    const candidates = staleMcpAuthCandidates(servers, knownConnectedMcpServers, session.mcpStatusRevalidatedAt);
+async function loadReconciledMcpStatuses(session, isActive = () => true) {
+    const servers = await session.query.mcpServerStatus();
+    if (!isActive()) {
+        return undefined;
+    }
+    return await reconcileSuspiciousMcpStatuses(session, servers.map(mapMcpServerStatus), isActive);
+}
+async function reconcileSuspiciousMcpStatuses(session, servers, isActive = () => true) {
+    const candidates = staleMcpAuthCandidates(servers, session.knownConnectedMcpServers, session.mcpStatusRevalidatedAt);
     if (candidates.length === 0) {
         return servers;
     }
     const now = Date.now();
     for (const serverName of candidates) {
+        if (!isActive()) {
+            return undefined;
+        }
         session.mcpStatusRevalidatedAt.set(serverName, now);
         bridgeLogger.info({
             target: LOG_TARGETS.BRIDGE_MCP,
@@ -165,8 +140,14 @@ async function reconcileSuspiciousMcpStatuses(session, servers) {
         });
         try {
             await session.query.reconnectMcpServer(serverName);
+            if (!isActive()) {
+                return undefined;
+            }
         }
         catch (error) {
+            if (!isActive()) {
+                return undefined;
+            }
             const message = error instanceof Error ? error.message : String(error);
             bridgeLogger.warn({
                 target: LOG_TARGETS.BRIDGE_MCP,
@@ -182,35 +163,67 @@ async function reconcileSuspiciousMcpStatuses(session, servers) {
             });
         }
     }
-    return (await session.query.mcpServerStatus()).map(mapMcpServerStatus);
+    const refreshed = await session.query.mcpServerStatus();
+    return isActive() ? refreshed.map(mapMcpServerStatus) : undefined;
 }
 function shouldKeepMonitoringMcpAuth(server) {
     return server?.status === "needs-auth" || server?.status === "pending";
 }
-function scheduleMcpAuthSnapshotMonitor(session, serverName, attempt = 0) {
-    const maxAttempts = 180;
-    const delayMs = 1000;
-    setTimeout(() => {
-        void monitorMcpAuthSnapshot(session, serverName, attempt + 1, maxAttempts, delayMs);
-    }, delayMs);
+function logMcpAuthMonitorExhausted(session, serverName, result) {
+    bridgeLogger.warn({
+        target: LOG_TARGETS.BRIDGE_MCP,
+        eventName: "mcp_auth_monitor_exhausted",
+        message: "MCP authentication status monitor exhausted",
+        outcome: "failure",
+        sessionId: session.sessionId,
+        count: result.attempts,
+        fields: {
+            server_name: serverName,
+            attempts: result.attempts,
+            reason: result.reason,
+            ...(result.lastError ? { error_message: result.lastError } : {}),
+        },
+    });
 }
-async function monitorMcpAuthSnapshot(session, serverName, attempt, maxAttempts, delayMs) {
-    try {
-        const servers = await emitMcpSnapshotEvent(session);
-        const server = servers.find((candidate) => candidate.name === serverName);
-        if (attempt < maxAttempts && shouldKeepMonitoringMcpAuth(server)) {
-            setTimeout(() => {
-                void monitorMcpAuthSnapshot(session, serverName, attempt + 1, maxAttempts, delayMs);
-            }, delayMs);
-        }
+export function startMcpAuthSnapshotMonitor(session, serverName, timing = {}) {
+    if (session.closing) {
+        return Promise.resolve({ outcome: "cancelled", attempts: 0 });
     }
-    catch {
-        if (attempt < maxAttempts) {
-            setTimeout(() => {
-                void monitorMcpAuthSnapshot(session, serverName, attempt + 1, maxAttempts, delayMs);
-            }, delayMs);
-        }
+    const existing = session.mcpAuthMonitors.get(serverName);
+    if (existing) {
+        return existing.task;
     }
+    const controller = new AbortController();
+    let monitor;
+    const isActive = () => !session.closing &&
+        !controller.signal.aborted &&
+        session.mcpAuthMonitors.get(serverName) === monitor;
+    const task = runMcpAuthMonitor({
+        ...timing,
+        signal: controller.signal,
+        poll: async () => {
+            const servers = await loadReconciledMcpStatuses(session, isActive);
+            if (!isActive() || !servers) {
+                return "complete";
+            }
+            emitMcpSnapshotFromMappedStatuses(session, servers, "mcp_status");
+            const server = servers.find((candidate) => candidate.name === serverName);
+            return shouldKeepMonitoringMcpAuth(server) ? "continue" : "complete";
+        },
+    }).then((result) => {
+        if (result.outcome === "exhausted") {
+            logMcpAuthMonitorExhausted(session, serverName, result);
+        }
+        return result;
+    });
+    monitor = { controller, task };
+    session.mcpAuthMonitors.set(serverName, monitor);
+    void task.then(() => {
+        if (session.mcpAuthMonitors.get(serverName) === monitor) {
+            session.mcpAuthMonitors.delete(serverName);
+        }
+    });
+    return task;
 }
 export async function handleMcpStatusCommand(session, requestId, source = "mcp_status") {
     try {
@@ -224,6 +237,7 @@ export async function handleMcpStatusCommand(session, requestId, source = "mcp_s
             session_id: session.sessionId,
             source,
             servers: [],
+            auth_capabilities: detectMcpAuthCapabilities(session.query),
             error: message,
         }, requestId);
     }
@@ -277,8 +291,7 @@ export async function handleMcpSetServersCommand(session, command, requestId) {
 }
 export async function handleMcpAuthenticateCommand(session, command, requestId) {
     try {
-        const result = await callMcpAuthMethod(session, "mcpAuthenticate", [command.server_name]);
-        const redirect = extractMcpAuthRedirect(command.server_name, result);
+        const redirect = await authenticateMcpServer(session.query, command.server_name);
         if (redirect) {
             logMcpSuccess("mcp_auth_redirect_emitted", "MCP auth redirect emitted", command.session_id, requestId, { server_name: command.server_name, requires_user_action: redirect.requires_user_action });
             writeEvent({
@@ -290,7 +303,7 @@ export async function handleMcpAuthenticateCommand(session, command, requestId)
         else {
             logMcpSuccess("mcp_authenticate_completed", "MCP authentication command completed", command.session_id, requestId, { server_name: command.server_name });
         }
-        scheduleMcpAuthSnapshotMonitor(session, command.server_name);
+        startMcpAuthSnapshotMonitor(session, command.server_name);
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);
@@ -300,8 +313,8 @@ export async function handleMcpAuthenticateCommand(session, command, requestId)
 }
 export async function handleMcpClearAuthCommand(session, command, requestId) {
     try {
-        await callMcpAuthMethod(session, "mcpClearAuth", [command.server_name]);
-        forgetKnownConnectedMcpServer(command.server_name);
+        await clearMcpServerAuth(session.query, command.server_name);
+        forgetKnownConnectedMcpServer(session, command.server_name);
         session.mcpStatusRevalidatedAt.delete(command.server_name);
         logMcpSuccess("mcp_clear_auth_completed", "MCP auth cleared", command.session_id, requestId, {
             server_name: command.server_name,
@@ -315,10 +328,7 @@ export async function handleMcpClearAuthCommand(session, command, requestId) {
 }
 export async function handleMcpOauthCallbackUrlCommand(session, command, requestId) {
     try {
-        await callMcpAuthMethod(session, "mcpSubmitOAuthCallbackUrl", [
-            command.server_name,
-            command.callback_url,
-        ]);
+        await submitMcpOAuthCallbackUrl(session.query, command.server_name, command.callback_url);
         logMcpSuccess("mcp_oauth_callback_completed", "MCP OAuth callback URL submitted", command.session_id, requestId, {
             server_name: command.server_name,
             callback_url_chars: command.callback_url.length,

package/agent-sdk/dist/bridge/mcp_auth_adapter.js

@@ -0,0 +1,67 @@
+const MCP_AUTH_METHODS = {
+    authenticate: "mcpAuthenticate",
+    clear_auth: "mcpClearAuth",
+    submit_oauth_callback_url: "mcpSubmitOAuthCallbackUrl",
+};
+function runtimeMethod(query, methodName) {
+    if ((!query || typeof query !== "object") && typeof query !== "function") {
+        return undefined;
+    }
+    const method = Reflect.get(query, methodName);
+    return typeof method === "function" ? method : undefined;
+}
+function requiredRuntimeMethod(query, methodName) {
+    const method = runtimeMethod(query, methodName);
+    if (!method) {
+        throw new Error(`installed SDK does not support ${methodName}`);
+    }
+    return method;
+}
+async function invokeRuntimeMethod(query, methodName, args) {
+    const method = requiredRuntimeMethod(query, methodName);
+    return await Reflect.apply(method, query, args);
+}
+export function detectMcpAuthCapabilities(query) {
+    return {
+        authenticate: runtimeMethod(query, MCP_AUTH_METHODS.authenticate) !== undefined,
+        clear_auth: runtimeMethod(query, MCP_AUTH_METHODS.clear_auth) !== undefined,
+        submit_oauth_callback_url: runtimeMethod(query, MCP_AUTH_METHODS.submit_oauth_callback_url) !== undefined,
+    };
+}
+function parseMcpAuthRedirect(serverName, value) {
+    if (value === undefined || value === null) {
+        return null;
+    }
+    if (typeof value !== "object" || Array.isArray(value)) {
+        throw new Error("installed SDK returned an invalid mcpAuthenticate response");
+    }
+    const authUrl = Reflect.get(value, "authUrl");
+    if (authUrl === undefined || authUrl === null) {
+        return null;
+    }
+    if (typeof authUrl !== "string" || authUrl.trim().length === 0) {
+        throw new Error("installed SDK returned an invalid mcpAuthenticate authUrl");
+    }
+    const requiresUserAction = Reflect.get(value, "requiresUserAction");
+    if (requiresUserAction !== undefined && typeof requiresUserAction !== "boolean") {
+        throw new Error("installed SDK returned an invalid mcpAuthenticate requiresUserAction");
+    }
+    return {
+        server_name: serverName,
+        auth_url: authUrl,
+        requires_user_action: requiresUserAction === true,
+    };
+}
+export async function authenticateMcpServer(query, serverName) {
+    const result = await invokeRuntimeMethod(query, MCP_AUTH_METHODS.authenticate, [serverName]);
+    return parseMcpAuthRedirect(serverName, result);
+}
+export async function clearMcpServerAuth(query, serverName) {
+    await invokeRuntimeMethod(query, MCP_AUTH_METHODS.clear_auth, [serverName]);
+}
+export async function submitMcpOAuthCallbackUrl(query, serverName, callbackUrl) {
+    await invokeRuntimeMethod(query, MCP_AUTH_METHODS.submit_oauth_callback_url, [
+        serverName,
+        callbackUrl,
+    ]);
+}

package/agent-sdk/dist/bridge/mcp_monitor.js

@@ -0,0 +1,59 @@
+import { setTimeout as delay } from "node:timers/promises";
+const DEFAULT_MAX_ATTEMPTS = 24;
+const DEFAULT_INITIAL_DELAY_MS = 1_000;
+const DEFAULT_MAX_DELAY_MS = 10_000;
+async function abortableDelay(delayMs, signal) {
+    await delay(delayMs, undefined, { signal, ref: false });
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+export async function runMcpAuthMonitor({ signal, poll, maxAttempts = DEFAULT_MAX_ATTEMPTS, initialDelayMs = DEFAULT_INITIAL_DELAY_MS, maxDelayMs = DEFAULT_MAX_DELAY_MS, sleep = abortableDelay, }) {
+    let nextDelayMs = initialDelayMs;
+    let lastError;
+    for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+        try {
+            await sleep(nextDelayMs, signal);
+        }
+        catch (error) {
+            if (signal.aborted) {
+                return { outcome: "cancelled", attempts: attempt - 1 };
+            }
+            lastError = errorMessage(error);
+            if (attempt === maxAttempts) {
+                return { outcome: "exhausted", attempts: attempt, reason: "error", lastError };
+            }
+            nextDelayMs = Math.min(nextDelayMs * 2, maxDelayMs);
+            continue;
+        }
+        if (signal.aborted) {
+            return { outcome: "cancelled", attempts: attempt - 1 };
+        }
+        try {
+            const result = await poll();
+            if (signal.aborted) {
+                return { outcome: "cancelled", attempts: attempt };
+            }
+            if (result === "complete") {
+                return { outcome: "completed", attempts: attempt };
+            }
+            lastError = undefined;
+        }
+        catch (error) {
+            if (signal.aborted) {
+                return { outcome: "cancelled", attempts: attempt };
+            }
+            lastError = errorMessage(error);
+        }
+        if (attempt === maxAttempts) {
+            return {
+                outcome: "exhausted",
+                attempts: attempt,
+                reason: lastError ? "error" : "status",
+                ...(lastError ? { lastError } : {}),
+            };
+        }
+        nextDelayMs = Math.min(nextDelayMs * 2, maxDelayMs);
+    }
+    return { outcome: "exhausted", attempts: 0, reason: "status" };
+}

package/agent-sdk/dist/bridge/message_handlers.js

@@ -1,14 +1,14 @@
 import { asRecordOrNull } from "./shared.js";
 import { toPermissionMode, buildModeState, refreshSupportedModesForSession } from "./commands.js";
 import { writeEvent, emitSessionUpdate, emitConnectEvent, emitSessionReplacedEvent, } from "./events.js";
-import { TOOL_RESULT_TYPES, isToolSearchToolName, isToolSearchToolResultType, unwrapToolUseResult, } from "./tooling.js";
+import { TOOL_RESULT_TYPES, isToolSearchToolName, isToolSearchToolResultType, unwrapToolUseResult, parseToolNonExecutionMetadata, } from "./tooling.js";
 import { emitToolCall, emitToolCallUpdate, emitToolResultUpdate, finalizeOpenToolCalls, emitToolProgressUpdate, emitToolSummaryUpdate, ensureToolCallVisible, resolveTaskToolUseId, defersTaskNotificationCompletion, toolAcceptsTaskLifecycle, taskProgressText, taskUpdatedFields, } from "./tool_calls.js";
 import { applyBackgroundTasksChanged, applyTaskLifecycleState } from "./tasks.js";
 import { linkTaskToolUse, unlinkTaskToolUse } from "./task_links.js";
-import { emitAuthRequired, classifyTurnErrorKind, emitFastModeUpdateIfChanged } from "./error_classification.js";
+import { emitAuthRequired, classifyTurnErrorKind, emitFastModeUpdate, emitFastModeUpdateIfChanged, setFastModeSnapshotIfChanged, } from "./error_classification.js";
 import { mapAvailableAgentsFromNames, emitAvailableAgentsIfChanged, refreshAvailableAgents } from "./agents.js";
 import { mapInitSlashCommands, mapSdkSlashCommands, updateAvailableCommands, } from "./available_commands.js";
-import { buildApiRetryUpdate, buildRateLimitUpdate, buildSubagentRetryUpdate, normalizeSettingsParseErrors, numberField, parseApiRetryError, parseRuntimeSessionState, } from "./state_parsing.js";
+import { buildApiRetryUpdate, buildRateLimitUpdate, buildSubagentRetryUpdate, normalizeSettingsParseErrors, nonNegativeIntegerField, numberField, parseApiRetryError, parseRuntimeSessionState, } from "./state_parsing.js";
 import { looksLikeAuthRequired } from "./auth.js";
 import { emitCurrentModelUpdate, refreshCurrentModel, updateSessionId } from "./session_lifecycle.js";
 import { bridgeLogger, LOG_TARGETS } from "./logger.js";
@@ -576,6 +576,18 @@ function logContentBlockLinkage(session, blockType, toolUseId, toolName, linkage
         },
     });
 }
+function resolveToolProgressTarget(session, taskToolUseId, toolUseId, parentToolUseId) {
+    if (taskToolUseId && session.toolCalls.has(taskToolUseId)) {
+        return { toolUseId: taskToolUseId, source: "task" };
+    }
+    if (toolUseId && session.toolCalls.has(toolUseId)) {
+        return { toolUseId, source: "tool" };
+    }
+    if (parentToolUseId && session.toolCalls.has(parentToolUseId)) {
+        return { toolUseId: parentToolUseId, source: "parent" };
+    }
+    return null;
+}
 function hideToolUse(session, toolUseId) {
     if (toolUseId) {
         session.hiddenToolUseIds.add(toolUseId);
@@ -744,6 +756,7 @@ export function handleUserToolResultBlocks(session, message) {
         return false;
     }
     const content = Array.isArray(messageObject.content) ? messageObject.content : [];
+    const nonExecutionByToolUseId = parseToolNonExecutionMetadata(message.tool_result_meta);
     let handled = false;
     for (const block of content) {
         if (!block || typeof block !== "object") {
@@ -766,13 +779,13 @@ export function handleUserToolResultBlocks(session, message) {
                 parentToolUseId,
                 sourceMessageUuid: sourceMessageUuid(message),
             });
-            emitToolResultUpdate(session, toolUseId, Boolean(blockRecord.is_error), blockRecord.content, messageToolUseResult(message) ?? blockRecord, sourceMessageUuid(message));
+            emitToolResultUpdate(session, toolUseId, Boolean(blockRecord.is_error), blockRecord.content, messageToolUseResult(message) ?? blockRecord, sourceMessageUuid(message), nonExecutionByToolUseId.get(toolUseId));
         }
     }
     return handled;
 }
 export function handleResultMessage(session, message) {
-    emitFastModeUpdateIfChanged(session, message.fast_mode_state);
+    emitFastModeUpdateIfChanged(session, message.fast_mode_state, message.fast_mode_disabled_reason);
     const terminalReason = terminalReasonFromValue(message.terminal_reason);
     const subtype = typeof message.subtype === "string" ? message.subtype : "";
     if (subtype === "success") {
@@ -979,7 +992,7 @@ export function handleSdkMessage(session, message) {
                 session.mode = incomingMode;
             }
             refreshSupportedModesForSession(session);
-            emitFastModeUpdateIfChanged(session, msg.fast_mode_state);
+            const fastModeChanged = setFastModeSnapshotIfChanged(session, msg.fast_mode_state, msg.fast_mode_disabled_reason);
             if (!session.connected) {
                 emitConnectEvent(session);
             }
@@ -996,6 +1009,9 @@ export function handleSdkMessage(session, message) {
                         mode: buildModeState(session, incomingMode),
                     });
                 }
+                if (fastModeChanged) {
+                    emitFastModeUpdate(session);
+                }
             }
             if (Array.isArray(msg.slash_commands)) {
                 updateAvailableCommands(session, "init_slash_commands", mapInitSlashCommands(msg.slash_commands));
@@ -1032,15 +1048,34 @@ export function handleSdkMessage(session, message) {
                 emitSessionUpdate(session.sessionId, { type: "current_mode_update", current_mode_id: mode });
             }
             if (msg.status === "compacting") {
-                emitSessionUpdate(session.sessionId, { type: "session_status_update", status: "compacting" });
+                emitSessionUpdate(session.sessionId, { type: "compaction_update", phase: "started" });
             }
             else if (msg.status === "requesting") {
                 emitSessionUpdate(session.sessionId, { type: "session_status_update", status: "requesting" });
             }
             else if (msg.status === null) {
+                if (msg.compact_result === "success") {
+                    emitSessionUpdate(session.sessionId, {
+                        type: "compaction_update",
+                        phase: "finished",
+                        result: "success",
+                    });
+                }
+                else if (msg.compact_result === "failed") {
+                    const compactError = typeof msg.compact_error === "string" && msg.compact_error.trim().length > 0
+                        ? msg.compact_error.trim()
+                        : undefined;
+                    emitSessionUpdate(session.sessionId, {
+                        type: "compaction_update",
+                        phase: "finished",
+                        result: "failed",
+                        error_code: compactError === "too_few_groups" ? "too_few_groups" : "unknown",
+                        ...(compactError ? { error: compactError } : {}),
+                    });
+                }
                 emitSessionUpdate(session.sessionId, { type: "session_status_update", status: "idle" });
             }
-            emitFastModeUpdateIfChanged(session, msg.fast_mode_state);
+            emitFastModeUpdateIfChanged(session, msg.fast_mode_state, msg.fast_mode_disabled_reason);
             return;
         }
         if (subtype === "compact_boundary") {
@@ -1049,12 +1084,17 @@ export function handleSdkMessage(session, message) {
                 return;
             }
             const trigger = compactMetadata.trigger;
-            const preTokens = numberField(compactMetadata, "pre_tokens", "preTokens");
+            const preTokens = nonNegativeIntegerField(compactMetadata, "pre_tokens", "preTokens");
+            const postTokens = nonNegativeIntegerField(compactMetadata, "post_tokens", "postTokens");
+            const durationMs = nonNegativeIntegerField(compactMetadata, "duration_ms", "durationMs");
             if ((trigger === "manual" || trigger === "auto") && preTokens !== undefined) {
                 emitSessionUpdate(session.sessionId, {
-                    type: "compaction_boundary",
+                    type: "compaction_update",
+                    phase: "boundary",
                     trigger,
                     pre_tokens: preTokens,
+                    ...(postTokens !== undefined ? { post_tokens: postTokens } : {}),
+                    ...(durationMs !== undefined ? { duration_ms: durationMs } : {}),
                 });
             }
             return;
@@ -1137,25 +1177,29 @@ export function handleSdkMessage(session, message) {
     if (type === "tool_progress") {
         const toolUseId = typeof msg.tool_use_id === "string" ? msg.tool_use_id : "";
         const toolName = typeof msg.tool_name === "string" ? msg.tool_name : "Tool";
+        const parentToolUseId = typeof msg.parent_tool_use_id === "string" ? msg.parent_tool_use_id : "";
         const taskId = typeof msg.task_id === "string" ? msg.task_id : "";
         const taskToolUseId = taskId ? session.taskToolUseIds.get(taskId) ?? "" : "";
-        const resolvedToolUseId = taskToolUseId || toolUseId;
-        if (isHiddenToolUse(session, resolvedToolUseId, toolName)) {
+        if (isHiddenToolUse(session, toolUseId, toolName)) {
             return;
         }
+        const progressTarget = resolveToolProgressTarget(session, taskToolUseId, toolUseId, parentToolUseId);
+        const resolvedToolUseId = progressTarget?.toolUseId ?? "";
         bridgeLogger.debug({
             target: LOG_TARGETS.APP_TOOL,
             eventName: "sdk_tool_progress_linkage_observed",
             message: "SDK tool progress linkage observed",
-            outcome: typeof msg.parent_tool_use_id === "string" ? "child" : "root_or_unknown",
+            outcome: progressTarget?.source ?? "orphaned",
             sessionId: session.sessionId,
-            toolCallId: resolvedToolUseId || undefined,
+            toolCallId: resolvedToolUseId || toolUseId || undefined,
             fields: {
                 tool_name: toolName,
                 tool_use_id: toolUseId || undefined,
-                parent_tool_use_id: typeof msg.parent_tool_use_id === "string" ? msg.parent_tool_use_id : undefined,
+                parent_tool_use_id: parentToolUseId || undefined,
                 task_id: taskId || undefined,
                 task_resolved_tool_use_id: taskToolUseId || undefined,
+                resolved_tool_use_id: resolvedToolUseId || undefined,
+                correlation_source: progressTarget?.source,
             },
         });
         if (resolvedToolUseId) {
@@ -1174,7 +1218,7 @@ export function handleSdkMessage(session, message) {
             const subagentType = typeof msg.subagent_type === "string" && msg.subagent_type.trim()
                 ? msg.subagent_type.trim()
                 : undefined;
-            emitToolProgressUpdate(session, resolvedToolUseId, toolName, {
+            emitToolProgressUpdate(session, resolvedToolUseId, {
                 ...(subagentRetry
                     ? { subagentRetry }
                     : hasSubagentRetry
@@ -1270,7 +1314,7 @@ export function handleSdkMessage(session, message) {
                 return;
             }
             const parsed = unwrapToolUseResult(rawToolUseResult);
-            emitToolResultUpdate(session, toolUseId, parsed.isError, parsed.content, rawToolUseResult, sourceMessageUuid(msg));
+            emitToolResultUpdate(session, toolUseId, parsed.isError, parsed.content, rawToolUseResult, sourceMessageUuid(msg), parseToolNonExecutionMetadata(msg.tool_result_meta).get(toolUseId));
         }
         return;
     }