claude-code-rust 0.12.3 → 0.12.4

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

@@ -95,6 +95,13 @@ function expectEffortLevel(record, key, context) {
     }
     return value;
 }
+function expectRewindRestoreMode(record, key, context) {
+    const value = expectString(record, key, context);
+    if (value === "both" || value === "conversation" || value === "code") {
+        return value;
+    }
+    throw new Error(`${context}.${key} must be one of both, conversation, code`);
+}
 function expectNonEmptyStringOrNull(record, key, context) {
     const value = record[key];
     if (value === null) {
@@ -281,6 +288,19 @@ export function parseCommandEnvelope(line) {
                     command: "get_context_usage",
                     session_id: expectString(raw, "session_id", "get_context_usage"),
                 };
+            case "get_rewind_targets":
+                return {
+                    command: "get_rewind_targets",
+                    session_id: expectString(raw, "session_id", "get_rewind_targets"),
+                };
+            case "rewind":
+                return {
+                    command: "rewind",
+                    session_id: expectString(raw, "session_id", "rewind"),
+                    target_user_message_id: expectString(raw, "target_user_message_id", "rewind"),
+                    restore_mode: expectRewindRestoreMode(raw, "restore_mode", "rewind"),
+                    launch_settings: optionalLaunchSettings(raw, "launch_settings", "rewind"),
+                };
             case "reload_plugins":
                 return {
                     command: "reload_plugins",

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

@@ -6,7 +6,9 @@ import { resolveCurrentModel } from "./session_lifecycle.js";
 const SESSION_LIST_LIMIT = 50;
 let sessionListingDir;
 export function buildSessionListOptions(dir, limit = SESSION_LIST_LIMIT) {
-    return dir ? { dir, includeWorktrees: true, limit } : { limit };
+    return dir
+        ? { dir, includeProgrammatic: true, includeWorktrees: true, limit }
+        : { includeProgrammatic: true, limit };
 }
 export function setSessionListingDir(dir) {
     sessionListingDir = dir;
@@ -121,6 +123,7 @@ function buildConnectBridgeEvent(session, eventName) {
             available_models: session.availableModels,
             mode: session.mode ? buildModeState(session, session.mode) : null,
             ...(historyUpdates && historyUpdates.length > 0 ? { history_updates: historyUpdates } : {}),
+            ...(session.restoredInput !== undefined ? { restored_input: session.restoredInput } : {}),
         }
         : {
             event: "connected",
@@ -144,6 +147,7 @@ function logConnectEventEmission(session, eventName, requestId) {
             history_update_count: session.resumeUpdates?.length ?? 0,
             available_model_count: session.availableModels.length,
             stale_session_count: session.sessionsToCloseAfterConnect?.length ?? 0,
+            has_restored_input: session.restoredInput !== undefined,
         },
     });
 }
@@ -151,10 +155,15 @@ export function emitConnectEvent(session) {
     const bridgeEvent = buildConnectBridgeEvent(session, session.connectEvent);
     logConnectEventEmission(session, session.connectEvent, session.connectRequestId);
     writeEvent(bridgeEvent, session.connectRequestId);
+    if (session.pendingRewindResult) {
+        writeEvent({ ...session.pendingRewindResult, session_id: session.sessionId }, session.connectRequestId);
+        session.pendingRewindResult = undefined;
+    }
     session.connectRequestId = undefined;
     session.connected = true;
     session.authHintSent = false;
     session.resumeUpdates = undefined;
+    session.restoredInput = undefined;
     const staleSessions = session.sessionsToCloseAfterConnect;
     session.sessionsToCloseAfterConnect = undefined;
     if (!staleSessions || staleSessions.length === 0) {
@@ -180,7 +189,12 @@ export function emitSessionReplacedEvent(session, requestId) {
     const bridgeEvent = buildConnectBridgeEvent(session, "session_replaced");
     logConnectEventEmission(session, "session_replaced", requestId);
     writeEvent(bridgeEvent, requestId);
+    if (session.pendingRewindResult) {
+        writeEvent({ ...session.pendingRewindResult, session_id: session.sessionId }, requestId);
+        session.pendingRewindResult = undefined;
+    }
     session.resumeUpdates = undefined;
+    session.restoredInput = undefined;
     refreshSessionsList();
 }
 export async function emitSessionsList(requestId) {

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

@@ -71,6 +71,10 @@ function commandSessionId(command) {
         case "question_response":
         case "elicitation_response":
         case "get_status_snapshot":
+        case "get_context_usage":
+        case "get_rewind_targets":
+        case "rewind":
+        case "reload_plugins":
         case "mcp_status":
         case "mcp_reconnect":
         case "mcp_toggle":
@@ -105,6 +109,8 @@ function commandToolCallId(command) {
         case "elicitation_response":
         case "get_status_snapshot":
         case "get_context_usage":
+        case "get_rewind_targets":
+        case "rewind":
         case "reload_plugins":
         case "mcp_status":
         case "mcp_reconnect":
@@ -141,6 +147,8 @@ function eventToolCallId(event) {
         case "sessions_listed":
         case "status_snapshot":
         case "context_usage":
+        case "rewind_targets":
+        case "rewind_result":
         case "mcp_snapshot":
             return undefined;
     }
@@ -183,6 +191,8 @@ function protocolEventLevel(event) {
         case "sessions_listed":
         case "status_snapshot":
         case "context_usage":
+        case "rewind_targets":
+        case "rewind_result":
         case "runtime_reload_completed":
         case "mcp_set_servers_result":
         case "mcp_snapshot":

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

@@ -90,6 +90,162 @@ function emitSystemNoticeUpdate(session, severity, message) {
     }
     emitSessionUpdate(session.sessionId, { type: "system_notice_update", severity, message: trimmed });
 }
+const MAX_INFORMATIONAL_DEDUP_KEYS = 256;
+function shouldEmitInformationalMessage(session, level, content, toolUseId) {
+    if (!toolUseId) {
+        return true;
+    }
+    const key = `${toolUseId}\u0000${level}\u0000${content}`;
+    if (session.informationalDedupKeys.has(key)) {
+        return false;
+    }
+    session.informationalDedupKeys.add(key);
+    while (session.informationalDedupKeys.size > MAX_INFORMATIONAL_DEDUP_KEYS) {
+        const first = session.informationalDedupKeys.values().next().value;
+        if (typeof first !== "string") {
+            break;
+        }
+        session.informationalDedupKeys.delete(first);
+    }
+    return true;
+}
+function handleInformationalSystemMessage(session, msg) {
+    const content = typeof msg.content === "string" ? msg.content.trim() : "";
+    if (!content) {
+        return;
+    }
+    const level = typeof msg.level === "string" ? msg.level : "info";
+    const toolUseId = typeof msg.tool_use_id === "string" ? msg.tool_use_id : "";
+    if (!shouldEmitInformationalMessage(session, level, content, toolUseId)) {
+        return;
+    }
+    switch (level) {
+        case "notice":
+            emitSystemNoticeUpdate(session, "info", content);
+            return;
+        case "suggestion":
+            emitSystemNoticeUpdate(session, "info", `Suggestion: ${content}`);
+            return;
+        case "warning":
+            emitSystemNoticeUpdate(session, "warning", content);
+            return;
+        case "info":
+            if (msg.prevent_continuation === true) {
+                emitSystemNoticeUpdate(session, "warning", content);
+            }
+            return;
+        default:
+            bridgeLogger.debug({
+                target: LOG_TARGETS.BRIDGE_SDK,
+                eventName: "sdk_informational_level_unhandled",
+                message: "SDK informational message ignored for unknown level",
+                outcome: "ignored",
+                sessionId: session.sessionId,
+                toolCallId: toolUseId || undefined,
+                fields: {
+                    informational_level: level,
+                },
+            });
+    }
+}
+function trimmedStringField(msg, field) {
+    const value = msg[field];
+    if (typeof value !== "string") {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    return trimmed ? trimmed : undefined;
+}
+function ensureSentencePunctuation(value) {
+    const trimmed = value.trim();
+    if (!trimmed) {
+        return "";
+    }
+    return /[.!?]$/.test(trimmed) ? trimmed : `${trimmed}.`;
+}
+function modelRefusalNoFallbackMessage(msg) {
+    const model = trimmedStringField(msg, "original_model") ?? "the selected model";
+    const base = `Could not continue with ${model}: model refused the request and no fallback model is configured.`;
+    const explanation = trimmedStringField(msg, "api_refusal_explanation");
+    const category = trimmedStringField(msg, "api_refusal_category");
+    const content = trimmedStringField(msg, "content");
+    const detail = explanation
+        ? `Reason: ${explanation}`
+        : category
+            ? `Refusal category: ${category}`
+            : content;
+    const detailSentence = detail ? ensureSentencePunctuation(detail) : "";
+    return detailSentence ? `${base} ${detailSentence}` : base;
+}
+function handleModelRefusalNoFallbackMessage(session, msg) {
+    const message = modelRefusalNoFallbackMessage(msg);
+    emitSystemNoticeUpdate(session, "warning", message);
+    bridgeLogger.info({
+        target: LOG_TARGETS.APP_SESSION,
+        eventName: "sdk_model_refusal_no_fallback_received",
+        message: "SDK model refusal without fallback received",
+        outcome: "success",
+        sessionId: session.sessionId,
+        requestId: trimmedStringField(msg, "request_id"),
+        fields: {
+            original_model: trimmedStringField(msg, "original_model"),
+            api_refusal_category: trimmedStringField(msg, "api_refusal_category"),
+            refused_user_message_uuid: trimmedStringField(msg, "refused_user_message_uuid"),
+            sdk_message_uuid: trimmedStringField(msg, "uuid"),
+            sdk_message_session_id: trimmedStringField(msg, "session_id"),
+            has_api_refusal_explanation: trimmedStringField(msg, "api_refusal_explanation") !== undefined,
+            has_content: trimmedStringField(msg, "content") !== undefined,
+        },
+    });
+}
+function workerShutdownMessage(reason) {
+    const trimmed = reason.trim();
+    return trimmed ? `Claude worker is shutting down: ${trimmed}` : "Claude worker is shutting down.";
+}
+function handleWorkerShuttingDownSystemMessage(session, msg) {
+    const reason = typeof msg.reason === "string" ? msg.reason.trim() : "";
+    if (!session.connected) {
+        bridgeLogger.debug({
+            target: LOG_TARGETS.BRIDGE_SDK,
+            eventName: "sdk_worker_shutdown_preconnect_ignored",
+            message: "SDK worker shutdown ignored before session connect",
+            outcome: "ignored",
+            sessionId: session.sessionId,
+            fields: {
+                reason: reason || undefined,
+            },
+        });
+        return;
+    }
+    session.pendingWorkerShutdown = { reason };
+}
+function cancelPendingWorkerShutdown(session) {
+    if (!session.pendingWorkerShutdown) {
+        return;
+    }
+    bridgeLogger.debug({
+        target: LOG_TARGETS.BRIDGE_SDK,
+        eventName: "sdk_worker_shutdown_cancelled",
+        message: "SDK worker shutdown ignored after later stream activity",
+        outcome: "ignored",
+        sessionId: session.sessionId,
+        fields: {
+            reason: session.pendingWorkerShutdown.reason || undefined,
+        },
+    });
+    session.pendingWorkerShutdown = undefined;
+}
+export function flushPendingWorkerShutdown(session) {
+    const pending = session.pendingWorkerShutdown;
+    if (!pending) {
+        return;
+    }
+    session.pendingWorkerShutdown = undefined;
+    if (!session.connected) {
+        return;
+    }
+    emitSystemNoticeUpdate(session, "warning", workerShutdownMessage(pending.reason));
+}
 function notificationSeverity(priority) {
     return priority === "high" || priority === "immediate" ? "warning" : "info";
 }
@@ -675,12 +831,19 @@ function terminalReasonFromValue(value) {
 export function handleSdkMessage(session, message) {
     const msg = message;
     const type = typeof msg.type === "string" ? msg.type : "";
+    const subtype = type === "system" && typeof msg.subtype === "string" ? msg.subtype : "";
+    if (subtype !== "worker_shutting_down") {
+        cancelPendingWorkerShutdown(session);
+    }
     logSdkMessageOrigin(session, msg);
     if (type === "system") {
-        const subtype = typeof msg.subtype === "string" ? msg.subtype : "";
         if (handleFallbackRetractionMessage(session, subtype, msg)) {
             return;
         }
+        if (subtype === "model_refusal_no_fallback") {
+            handleModelRefusalNoFallbackMessage(session, msg);
+            return;
+        }
         if (subtype === "commands_changed") {
             updateAvailableCommands(session, "commands_changed", mapSdkSlashCommands(msg.commands));
             return;
@@ -690,6 +853,14 @@ export function handleSdkMessage(session, message) {
             emitSystemNoticeUpdate(session, notificationSeverity(msg.priority), text);
             return;
         }
+        if (subtype === "informational") {
+            handleInformationalSystemMessage(session, msg);
+            return;
+        }
+        if (subtype === "worker_shutting_down") {
+            handleWorkerShuttingDownSystemMessage(session, msg);
+            return;
+        }
         if (subtype === "mirror_error") {
             const error = typeof msg.error === "string" ? msg.error : "";
             const key = asRecordOrNull(msg.key);

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

@@ -162,6 +162,23 @@ export async function closeSessionWithLogging(session, options = {}) {
         fields: { reason: options.reason ?? "unspecified" },
     });
 }
+export async function closeSessionsBeforeRegister(replacementSession, staleSessions, requestId) {
+    if (!staleSessions || staleSessions.length === 0) {
+        return;
+    }
+    for (const stale of staleSessions) {
+        if (stale === replacementSession) {
+            continue;
+        }
+        if (sessions.get(stale.sessionId) === stale) {
+            sessions.delete(stale.sessionId);
+        }
+        await closeSessionWithLogging(stale, {
+            reason: "stale_before_register",
+            requestId,
+        });
+    }
+}
 export async function closeAllSessions(options = {}) {
     const active = Array.from(sessions.values());
     sessions.clear();
@@ -187,6 +204,7 @@ export async function createSession(params) {
     const supportsBypassPermissionsMode = startupPermissionModeOptions(params.launchSettings).allowDangerouslySkipPermissions === true;
     const historyUpdateCount = params.resumeUpdates?.length ?? 0;
     const staleSessionCount = params.sessionsToCloseAfterConnect?.length ?? 0;
+    const staleSessionBeforeRegisterCount = params.sessionsToCloseBeforeRegister?.length ?? 0;
     let session;
     const sessionIdForLogs = () => session?.sessionId ?? provisionalSessionId;
     const canUseTool = async (toolName, inputData, options) => {
@@ -253,8 +271,10 @@ export async function createSession(params) {
             cwd: params.cwd,
             connect_event: params.connectEvent,
             resume_requested: params.resume !== undefined,
+            resume_session_at: params.resumeSessionAt ?? "<none>",
             history_update_count: historyUpdateCount,
             stale_session_count: staleSessionCount,
+            stale_session_before_register_count: staleSessionBeforeRegisterCount,
         },
     });
     try {
@@ -263,6 +283,7 @@ export async function createSession(params) {
             options: buildQueryOptions({
                 cwd: params.cwd,
                 resume: params.resume,
+                resumeSessionAt: params.resumeSessionAt,
                 launchSettings: params.launchSettings,
                 provisionalSessionId,
                 input,
@@ -287,6 +308,7 @@ export async function createSession(params) {
             fields: {
                 cwd: params.cwd,
                 resume_requested: params.resume !== undefined,
+                resume_session_at: params.resumeSessionAt ?? "<none>",
                 error_message: message,
             },
         });
@@ -319,12 +341,17 @@ export async function createSession(params) {
         pendingQuestions: new Map(),
         pendingUserDialogs: new Map(),
         pendingElicitations: new Map(),
+        informationalDedupKeys: new Set(),
         mcpStatusRevalidatedAt: new Map(),
         hiddenToolUseIds: new Set(),
         authHintSent: false,
         ...(params.resumeUpdates && params.resumeUpdates.length > 0
             ? { resumeUpdates: params.resumeUpdates }
             : {}),
+        ...(params.restoredInput !== undefined ? { restoredInput: params.restoredInput } : {}),
+        ...(params.pendingRewindResult !== undefined
+            ? { pendingRewindResult: params.pendingRewindResult }
+            : {}),
         ...(params.sessionsToCloseAfterConnect
             ? { sessionsToCloseAfterConnect: params.sessionsToCloseAfterConnect }
             : {}),
@@ -332,6 +359,7 @@ export async function createSession(params) {
     refreshCurrentModel(session);
     const { refreshSupportedModesForSession } = await import("./commands.js");
     refreshSupportedModesForSession(session);
+    await closeSessionsBeforeRegister(session, params.sessionsToCloseBeforeRegister, params.requestId);
     sessions.set(provisionalSessionId, session);
     bridgeLogger.info({
         target: LOG_TARGETS.APP_SESSION,
@@ -344,6 +372,7 @@ export async function createSession(params) {
             cwd: session.cwd,
             connect_event: session.connectEvent,
             resume_requested: params.resume !== undefined,
+            resume_session_at: params.resumeSessionAt ?? "<none>",
         },
     });
     bridgeLogger.info({
@@ -430,6 +459,11 @@ export async function createSession(params) {
                 const { handleSdkMessage } = await import("./message_handlers.js");
                 handleSdkMessage(session, message);
             }
+            {
+                // Lazy import to break circular dependency at module-evaluation time.
+                const { flushPendingWorkerShutdown } = await import("./message_handlers.js");
+                flushPendingWorkerShutdown(session);
+            }
             if (!session.connected) {
                 bridgeLogger.error({
                     target: LOG_TARGETS.APP_SESSION,
@@ -456,6 +490,7 @@ export async function createSession(params) {
             failConnection(`agent stream failed: ${message}`, params.requestId);
         }
     })();
+    return session;
 }
 function logSdkProcessSpawnStarted(options, includeArgsPreview) {
     bridgeLogger.info({
@@ -570,6 +605,7 @@ export function buildQueryOptions(params) {
         cwd: params.cwd,
         includePartialMessages: true,
         promptSuggestions: true,
+        enableFileCheckpointing: true,
         executable: "node",
         ...(params.resume ? {} : { sessionId: params.provisionalSessionId }),
         ...(settings ? { settings } : {}),
@@ -621,6 +657,7 @@ export function buildQueryOptions(params) {
         // --setting-sources argument.
         settingSources: DEFAULT_SETTING_SOURCES,
         resume: params.resume,
+        ...(params.resumeSessionAt ? { resumeSessionAt: params.resumeSessionAt } : {}),
         canUseTool: params.canUseTool,
         onElicitation: async (request) => {
             const requestId = randomUUID();

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

@@ -62,6 +62,9 @@ export function buildRateLimitUpdate(rateLimitInfo) {
         type: "rate_limit_update",
         status,
     };
+    if (info.errorCode === "credits_required") {
+        update.error_code = "credits_required";
+    }
     const resetsAt = numberField(info, "resetsAt");
     if (resetsAt !== undefined) {
         update.resets_at = resetsAt;
@@ -94,6 +97,12 @@ export function buildRateLimitUpdate(rateLimitInfo) {
     if (surpassedThreshold !== undefined) {
         update.surpassed_threshold = surpassedThreshold;
     }
+    if (typeof info.canUserPurchaseCredits === "boolean") {
+        update.can_user_purchase_credits = info.canUserPurchaseCredits;
+    }
+    if (typeof info.hasChargeableSavedPaymentMethod === "boolean") {
+        update.has_chargeable_saved_payment_method = info.hasChargeableSavedPaymentMethod;
+    }
     return update;
 }
 export function buildApiRetryUpdate(message) {

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

@@ -23,6 +23,8 @@ const WORKFLOW_TOOL_NAME = "Workflow";
 const PROJECTS_TOOL_NAME = "Projects";
 const ARTIFACT_TOOL_NAME = "Artifact";
 const SHOW_ONBOARDING_ROLE_PICKER_TOOL_NAME = "ShowOnboardingRolePicker";
+const READ_MCP_RESOURCE_TOOL_NAME = "ReadMcpResource";
+const READ_MCP_RESOURCE_DIR_TOOL_NAME = "ReadMcpResourceDir";
 const SEARCH_OUTPUT_MODES = new Set(["content", "files_with_matches", "count"]);
 function isCronToolName(name) {
     return CRON_TOOL_NAMES.has(name);
@@ -53,6 +55,9 @@ function isAgentLikeToolName(name) {
 export function isShellToolName(name) {
     return name === "Bash" || name === "PowerShell";
 }
+function isMcpResourceReadToolName(name) {
+    return name === READ_MCP_RESOURCE_TOOL_NAME || name === READ_MCP_RESOURCE_DIR_TOOL_NAME;
+}
 function agentInputTitle(name, input) {
     if (!isAgentLikeToolName(name)) {
         return undefined;
@@ -143,7 +148,8 @@ export function normalizeToolKind(name) {
     }
     switch (name) {
         case "Read":
-        case "ReadMcpResource":
+        case READ_MCP_RESOURCE_TOOL_NAME:
+        case READ_MCP_RESOURCE_DIR_TOOL_NAME:
             return "read";
         case "Write":
         case "Edit":
@@ -268,14 +274,14 @@ export function toolTitle(name, input, context = {}) {
     if ((name === "Read" || name === "Write" || name === "Edit") && typeof input.file_path === "string") {
         return `${name} ${input.file_path}`;
     }
-    if (name === "ReadMcpResource") {
+    if (isMcpResourceReadToolName(name)) {
         const uri = typeof input.uri === "string" ? input.uri : "";
         const server = typeof input.server === "string" ? input.server : "";
         if (server && uri) {
-            return `ReadMcpResource ${server} ${uri}`;
+            return `${name} ${server} ${uri}`;
         }
         if (uri) {
-            return `ReadMcpResource ${uri}`;
+            return `${name} ${uri}`;
         }
     }
     return name;
@@ -440,6 +446,37 @@ function mcpResourceContentFromResult(rawResult, rawContent) {
     }
     return [];
 }
+function mcpResourceDirTextFromResult(toolName, rawResult, rawContent) {
+    if (toolName !== READ_MCP_RESOURCE_DIR_TOOL_NAME) {
+        return undefined;
+    }
+    for (const candidate of collectResultCandidates(rawResult, rawContent)) {
+        if (!Array.isArray(candidate.resources)) {
+            continue;
+        }
+        const lines = [];
+        for (const entry of candidate.resources) {
+            const record = asRecordOrNull(entry);
+            if (!record) {
+                continue;
+            }
+            const name = nonEmptyString(record.name);
+            const uri = nonEmptyString(record.uri);
+            if (!name || !uri) {
+                continue;
+            }
+            const mimeType = nonEmptyString(record.mimeType);
+            const suffix = mimeType
+                ? mimeType === "inode/directory"
+                    ? " (directory)"
+                    : ` (${mimeType})`
+                : "";
+            lines.push(`${name} - ${uri}${suffix}`);
+        }
+        return lines.length > 0 ? lines.join("\n") : "No resources found.";
+    }
+    return undefined;
+}
 function extractToolOutputMetadata(toolName, rawResult, rawContent) {
     const candidates = collectResultCandidates(rawResult, rawContent);
     const metadata = {};
@@ -1604,8 +1641,8 @@ function enterPlanModeStructuredOutputHandled(toolName, rawResult, rawContent) {
     }
     return false;
 }
-function readMcpResourceErrorText(toolName, rawResult, rawContent) {
-    if (toolName !== "ReadMcpResource") {
+function mcpResourceReadErrorText(toolName, rawResult, rawContent) {
+    if (!isMcpResourceReadToolName(toolName)) {
         return undefined;
     }
     for (const candidate of collectResultCandidates(rawResult, rawContent)) {
@@ -1675,13 +1712,23 @@ export function buildToolResultFields(isError, rawContent, base, rawResult, _con
     if (agentTitle) {
         fields.title = agentTitle;
     }
-    const readMcpResourceError = readMcpResourceErrorText(toolName, rawResult, rawContent);
+    const readMcpResourceError = mcpResourceReadErrorText(toolName, rawResult, rawContent);
     if (readMcpResourceError) {
         fields.status = "failed";
         fields.raw_output = readMcpResourceError;
         fields.content = [{ type: "content", content: { type: "text", text: readMcpResourceError } }];
         return fields;
     }
+    const readMcpResourceDirOutput = !isError
+        ? mcpResourceDirTextFromResult(toolName, rawResult, rawContent)
+        : undefined;
+    if (readMcpResourceDirOutput !== undefined) {
+        fields.raw_output = readMcpResourceDirOutput;
+        fields.content = [
+            { type: "content", content: { type: "text", text: readMcpResourceDirOutput } },
+        ];
+        return fields;
+    }
     const searchOutput = !isError ? searchResultText(toolName, rawResult, rawContent) : undefined;
     if (searchOutput !== undefined) {
         fields.raw_output = searchOutput;
@@ -1826,7 +1873,7 @@ export function buildToolResultFields(isError, rawContent, base, rawResult, _con
             return fields;
         }
     }
-    if (!isError && toolName === "ReadMcpResource") {
+    if (!isError && toolName === READ_MCP_RESOURCE_TOOL_NAME) {
         const structuredResourceContent = mcpResourceContentFromResult(rawResult, rawContent);
         if (structuredResourceContent.length > 0) {
             fields.content = structuredResourceContent;