claude-code-rust 0.7.1 → 0.8.1

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

@@ -13,6 +13,9 @@ export const sessions = new Map();
 const DEFAULT_SETTING_SOURCES = ["user", "project", "local"];
 const DEFAULT_MODEL_NAME = "default";
 const DEFAULT_PERMISSION_MODE = "default";
+function settingsObjectFromLaunchSettings(launchSettings) {
+    return launchSettings.settings;
+}
 export function sessionById(sessionId) {
     return sessions.get(sessionId) ?? null;
 }
@@ -32,6 +35,14 @@ export async function closeSession(session) {
         pending.onOutcome?.({ outcome: "cancelled" });
     }
     session.pendingPermissions.clear();
+    for (const pending of session.pendingQuestions.values()) {
+        pending.onOutcome({ outcome: "cancelled" });
+    }
+    session.pendingQuestions.clear();
+    for (const pending of session.pendingElicitations.values()) {
+        pending.resolve({ action: "cancel" });
+    }
+    session.pendingElicitations.clear();
 }
 export async function closeAllSessions() {
     const active = Array.from(sessions.values());
@@ -54,7 +65,7 @@ export async function createSession(params) {
             `decision_reason=${options.decisionReason ?? "<none>"} suggestions=${formatPermissionUpdates(options.suggestions)}`);
         const existing = ensureToolCallVisible(session, toolUseId, toolName, inputData);
         if (toolName === ASK_USER_QUESTION_TOOL_NAME) {
-            return await requestAskUserQuestionAnswers(session, toolUseId, toolName, inputData, existing);
+            return await requestAskUserQuestionAnswers(session, toolUseId, inputData, existing);
         }
         const request = {
             tool_call: existing,
@@ -117,6 +128,9 @@ export async function createSession(params) {
         toolCalls: new Map(),
         taskToolUseIds: new Map(),
         pendingPermissions: new Map(),
+        pendingQuestions: new Map(),
+        pendingElicitations: new Map(),
+        mcpStatusRevalidatedAt: new Map(),
         authHintSent: false,
         ...(params.resumeUpdates && params.resumeUpdates.length > 0
             ? { resumeUpdates: params.resumeUpdates }
@@ -183,8 +197,8 @@ export async function createSession(params) {
         }
     })();
 }
-function permissionModeFromLaunchSettings(rawMode) {
-    if (rawMode === undefined) {
+function permissionModeFromSettingsValue(rawMode) {
+    if (typeof rawMode !== "string") {
         return undefined;
     }
     switch (rawMode) {
@@ -195,32 +209,41 @@ function permissionModeFromLaunchSettings(rawMode) {
         case "dontAsk":
             return rawMode;
         default:
-            throw new Error(`unsupported launch_settings.permission_mode: ${rawMode}`);
+            throw new Error(`unsupported launch_settings.settings.permissions.defaultMode: ${rawMode}`);
     }
 }
 function initialSessionModel(launchSettings) {
-    return launchSettings.model?.trim() || DEFAULT_MODEL_NAME;
+    const settings = settingsObjectFromLaunchSettings(launchSettings);
+    const model = typeof settings?.model === "string" ? settings.model.trim() : "";
+    return model || DEFAULT_MODEL_NAME;
 }
-function initialSessionMode(launchSettings) {
-    return permissionModeFromLaunchSettings(launchSettings.permission_mode) ?? DEFAULT_PERMISSION_MODE;
+function startupModelOption(launchSettings) {
+    const settings = settingsObjectFromLaunchSettings(launchSettings);
+    const model = typeof settings?.model === "string" ? settings.model.trim() : "";
+    return model ? { model } : {};
 }
-function thinkingConfigFromLaunchSettings(launchSettings) {
-    switch (launchSettings.thinking_mode) {
-        case undefined:
-            return undefined;
-        case "adaptive":
-            return { type: "adaptive" };
-        case "disabled":
-            return { type: "disabled" };
-        default:
-            throw new Error(`unsupported launch_settings.thinking_mode: ${String(launchSettings.thinking_mode)}`);
-    }
+function initialSessionMode(launchSettings) {
+    const settings = settingsObjectFromLaunchSettings(launchSettings);
+    const permissions = settings?.permissions && typeof settings.permissions === "object" && !Array.isArray(settings.permissions)
+        ? settings.permissions
+        : undefined;
+    return permissionModeFromSettingsValue(permissions?.defaultMode) ?? DEFAULT_PERMISSION_MODE;
 }
-function effortFromLaunchSettings(launchSettings) {
-    if (launchSettings.thinking_mode !== "adaptive") {
-        return undefined;
+function startupPermissionModeOptions(launchSettings) {
+    const settings = settingsObjectFromLaunchSettings(launchSettings);
+    const permissions = settings?.permissions && typeof settings.permissions === "object" && !Array.isArray(settings.permissions)
+        ? settings.permissions
+        : undefined;
+    const permissionMode = permissionModeFromSettingsValue(permissions?.defaultMode);
+    if (!permissionMode) {
+        return {};
     }
-    return launchSettings.effort_level;
+    return permissionMode === "bypassPermissions"
+        ? {
+            permissionMode,
+            allowDangerouslySkipPermissions: true,
+        }
+        : { permissionMode };
 }
 function systemPromptFromLaunchSettings(launchSettings) {
     const language = launchSettings.language?.trim();
@@ -235,20 +258,22 @@ function systemPromptFromLaunchSettings(launchSettings) {
     };
 }
 export function buildQueryOptions(params) {
-    const permissionMode = permissionModeFromLaunchSettings(params.launchSettings.permission_mode);
-    const thinking = thinkingConfigFromLaunchSettings(params.launchSettings);
-    const effort = effortFromLaunchSettings(params.launchSettings);
     const systemPrompt = systemPromptFromLaunchSettings(params.launchSettings);
+    const modelOption = startupModelOption(params.launchSettings);
+    const permissionModeOptions = startupPermissionModeOptions(params.launchSettings);
     return {
         cwd: params.cwd,
         includePartialMessages: true,
         executable: "node",
         ...(params.resume ? {} : { sessionId: params.provisionalSessionId }),
-        ...(params.launchSettings.model ? { model: params.launchSettings.model } : {}),
+        ...(params.launchSettings.settings ? { settings: params.launchSettings.settings } : {}),
+        ...modelOption,
+        ...permissionModeOptions,
+        toolConfig: { askUserQuestion: { previewFormat: "markdown" } },
         ...(systemPrompt ? { systemPrompt } : {}),
-        ...(permissionMode ? { permissionMode } : {}),
-        ...(thinking ? { thinking } : {}),
-        ...(effort ? { effort } : {}),
+        ...(params.launchSettings.agent_progress_summaries !== undefined
+            ? { agentProgressSummaries: params.launchSettings.agent_progress_summaries }
+            : {}),
         ...(params.claudeCodeExecutable
             ? { pathToClaudeCodeExecutable: params.claudeCodeExecutable }
             : {}),
@@ -283,21 +308,52 @@ export function buildQueryOptions(params) {
         resume: params.resume,
         canUseTool: params.canUseTool,
         onElicitation: async (request) => {
-            const requestMode = typeof request.mode === "string" ? request.mode : "unknown";
-            const requestServer = typeof request.serverName === "string" && request.serverName.trim().length > 0
-                ? request.serverName
-                : "unknown";
-            const requestMessage = typeof request.message === "string" && request.message.trim().length > 0
-                ? request.message
-                : "<no message>";
-            console.error(`[sdk warn] elicitation unsupported without MCP settings UI; ` +
-                `auto-canceling session_id=${params.sessionIdForLogs()} server=${requestServer} ` +
-                `mode=${requestMode} message=${JSON.stringify(requestMessage)}`);
-            return { action: "cancel" };
+            const requestId = randomUUID();
+            const mode = request.mode === "form" || request.mode === "url"
+                ? request.mode
+                : typeof request.url === "string" && request.url.trim().length > 0
+                    ? "url"
+                    : "form";
+            const normalized = {
+                request_id: requestId,
+                server_name: typeof request.serverName === "string" && request.serverName.trim().length > 0
+                    ? request.serverName
+                    : "unknown",
+                message: typeof request.message === "string" && request.message.trim().length > 0
+                    ? request.message
+                    : "<no message>",
+                mode,
+                ...(typeof request.url === "string" && request.url.trim().length > 0
+                    ? { url: request.url }
+                    : {}),
+                ...(typeof request.elicitationId === "string" && request.elicitationId.trim().length > 0
+                    ? { elicitation_id: request.elicitationId }
+                    : {}),
+                ...(request.requestedSchema
+                    ? { requested_schema: request.requestedSchema }
+                    : {}),
+            };
+            writeEvent({
+                event: "elicitation_request",
+                session_id: params.sessionIdForLogs(),
+                request: normalized,
+            });
+            return await new Promise((resolve) => {
+                const currentSession = sessions.get(params.sessionIdForLogs());
+                if (!currentSession) {
+                    resolve({ action: "cancel" });
+                    return;
+                }
+                currentSession.pendingElicitations.set(requestId, {
+                    resolve,
+                    serverName: normalized.server_name,
+                    elicitationId: normalized.elicitation_id,
+                });
+            });
         },
     };
 }
-function mapAvailableModels(models) {
+export function mapAvailableModels(models) {
     if (!Array.isArray(models)) {
         return [];
     }
@@ -315,6 +371,15 @@ function mapAvailableModels(models) {
         supported_effort_levels: Array.isArray(entry.supportedEffortLevels)
             ? entry.supportedEffortLevels.filter((level) => level === "low" || level === "medium" || level === "high")
             : [],
+        ...(typeof entry.supportsAdaptiveThinking === "boolean"
+            ? { supports_adaptive_thinking: entry.supportsAdaptiveThinking }
+            : {}),
+        ...(typeof entry.supportsFastMode === "boolean"
+            ? { supports_fast_mode: entry.supportsFastMode }
+            : {}),
+        ...(typeof entry.supportsAutoMode === "boolean"
+            ? { supports_auto_mode: entry.supportsAutoMode }
+            : {}),
         ...(typeof entry.description === "string" && entry.description.trim().length > 0
             ? { description: entry.description }
             : {}),
@@ -366,3 +431,36 @@ export function handlePermissionResponse(command) {
     }
     resolver.resolve(permissionResult);
 }
+export function handleQuestionResponse(command) {
+    const session = sessionById(command.session_id);
+    if (!session) {
+        logPermissionDebug(`question response dropped: unknown session session_id=${command.session_id} tool_call_id=${command.tool_call_id}`);
+        return;
+    }
+    const resolver = session.pendingQuestions.get(command.tool_call_id);
+    if (!resolver) {
+        logPermissionDebug(`question response dropped: no pending resolver session_id=${command.session_id} tool_call_id=${command.tool_call_id}`);
+        return;
+    }
+    session.pendingQuestions.delete(command.tool_call_id);
+    resolver.onOutcome(command.outcome);
+}
+export function handleElicitationResponse(command) {
+    const session = sessionById(command.session_id);
+    if (!session) {
+        console.error(`[sdk warn] elicitation response dropped: unknown session ` +
+            `session_id=${command.session_id} request_id=${command.elicitation_request_id}`);
+        return;
+    }
+    const pending = session.pendingElicitations.get(command.elicitation_request_id);
+    if (!pending) {
+        console.error(`[sdk warn] elicitation response dropped: no pending request ` +
+            `session_id=${command.session_id} request_id=${command.elicitation_request_id}`);
+        return;
+    }
+    session.pendingElicitations.delete(command.elicitation_request_id);
+    pending.resolve({
+        action: command.action,
+        ...(command.content ? { content: command.content } : {}),
+    });
+}

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

@@ -67,9 +67,9 @@ export function emitPlanIfTodoWrite(session, name, input) {
         emitSessionUpdate(session.sessionId, { type: "plan", entries });
     }
 }
-export function emitToolResultUpdate(session, toolUseId, isError, rawContent) {
+export function emitToolResultUpdate(session, toolUseId, isError, rawContent, rawResult = rawContent) {
     const base = session.toolCalls.get(toolUseId);
-    const fields = buildToolResultFields(isError, rawContent, base);
+    const fields = buildToolResultFields(isError, rawContent, base, rawResult);
     const update = { tool_call_id: toolUseId, fields };
     emitSessionUpdate(session.sessionId, { type: "tool_call_update", tool_call_update: update });
     if (base) {
@@ -80,6 +80,9 @@ export function emitToolResultUpdate(session, toolUseId, isError, rawContent) {
         if (fields.content) {
             base.content = fields.content;
         }
+        if (fields.output_metadata) {
+            base.output_metadata = fields.output_metadata;
+        }
     }
 }
 export function finalizeOpenToolCalls(session, status) {
@@ -101,7 +104,9 @@ export function emitToolProgressUpdate(session, toolUseId, toolName) {
         emitToolCall(session, toolUseId, toolName, {});
         return;
     }
-    if (existing.status === "in_progress") {
+    if (existing.status === "in_progress" ||
+        existing.status === "completed" ||
+        existing.status === "failed") {
         return;
     }
     const fields = { status: "in_progress" };
@@ -159,6 +164,10 @@ export function resolveTaskToolUseId(session, msg) {
     return session.taskToolUseIds.get(taskId) ?? "";
 }
 export function taskProgressText(msg) {
+    const summary = typeof msg.summary === "string" ? msg.summary.trim() : "";
+    if (summary) {
+        return summary;
+    }
     const description = typeof msg.description === "string" ? msg.description : "";
     const lastTool = typeof msg.last_tool_name === "string" ? msg.last_tool_name : "";
     if (description && lastTool) {

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

@@ -18,6 +18,7 @@ export function normalizeToolKind(name) {
         case "Bash":
             return "execute";
         case "Read":
+        case "ReadMcpResource":
             return "read";
         case "Write":
         case "Edit":
@@ -75,6 +76,16 @@ export function toolTitle(name, input) {
     if ((name === "Read" || name === "Write" || name === "Edit") && typeof input.file_path === "string") {
         return `${name} ${input.file_path}`;
     }
+    if (name === "ReadMcpResource") {
+        const uri = typeof input.uri === "string" ? input.uri : "";
+        const server = typeof input.server === "string" ? input.server : "";
+        if (server && uri) {
+            return `ReadMcpResource ${server} ${uri}`;
+        }
+        if (uri) {
+            return `ReadMcpResource ${uri}`;
+        }
+    }
     return name;
 }
 function editDiffContent(name, input) {
@@ -115,6 +126,145 @@ export function createToolCall(toolUseId, name, input) {
         },
     };
 }
+function resultRecordCandidates(rawResult, rawContent) {
+    const candidates = [];
+    const pushRecord = (value) => {
+        const record = asRecordOrNull(value);
+        if (record) {
+            candidates.push(record);
+        }
+    };
+    const pushNestedRecords = (value) => {
+        const record = asRecordOrNull(value);
+        if (!record) {
+            return;
+        }
+        pushRecord(record.result);
+        pushRecord(record.data);
+        pushRecord(record.content);
+    };
+    pushRecord(rawResult);
+    pushNestedRecords(rawResult);
+    pushRecord(rawContent);
+    pushNestedRecords(rawContent);
+    return candidates;
+}
+function parseJsonCandidate(value) {
+    const text = typeof value === "string" ? value : extractText(value);
+    const trimmed = text.trim();
+    if (!(trimmed.startsWith("{") || trimmed.startsWith("["))) {
+        return undefined;
+    }
+    try {
+        return JSON.parse(trimmed);
+    }
+    catch {
+        return undefined;
+    }
+}
+function pushStructuredRecordCandidates(candidates, value) {
+    const record = asRecordOrNull(value);
+    if (!record) {
+        return;
+    }
+    candidates.push(record);
+    const nestedResult = asRecordOrNull(record.result);
+    if (nestedResult) {
+        candidates.push(nestedResult);
+    }
+    const nestedData = asRecordOrNull(record.data);
+    if (nestedData) {
+        candidates.push(nestedData);
+    }
+    const nestedContent = asRecordOrNull(record.content);
+    if (nestedContent) {
+        candidates.push(nestedContent);
+    }
+}
+function mcpResourceContentFromResult(rawResult, rawContent) {
+    const candidates = [];
+    for (const candidate of [rawResult, rawContent, parseJsonCandidate(rawResult), parseJsonCandidate(rawContent)]) {
+        pushStructuredRecordCandidates(candidates, candidate);
+    }
+    for (const candidate of candidates) {
+        const contents = Array.isArray(candidate.contents) ? candidate.contents : null;
+        if (!contents || contents.length === 0) {
+            continue;
+        }
+        const mapped = [];
+        for (const entry of contents) {
+            const record = asRecordOrNull(entry);
+            if (!record) {
+                continue;
+            }
+            const uri = typeof record.uri === "string" ? record.uri : "";
+            if (!uri) {
+                continue;
+            }
+            const text = typeof record.text === "string" && record.text.length > 0 ? record.text : undefined;
+            const mimeType = typeof record.mimeType === "string" && record.mimeType.trim().length > 0
+                ? record.mimeType.trim()
+                : undefined;
+            const blobSavedTo = typeof record.blobSavedTo === "string" && record.blobSavedTo.trim().length > 0
+                ? record.blobSavedTo.trim()
+                : undefined;
+            if (!text && !blobSavedTo) {
+                continue;
+            }
+            mapped.push({
+                type: "mcp_resource",
+                uri,
+                ...(mimeType ? { mime_type: mimeType } : {}),
+                ...(text ? { text } : {}),
+                ...(blobSavedTo ? { blob_saved_to: blobSavedTo } : {}),
+            });
+        }
+        if (mapped.length > 0) {
+            return mapped;
+        }
+    }
+    return [];
+}
+function extractToolOutputMetadata(toolName, rawResult, rawContent) {
+    const candidates = resultRecordCandidates(rawResult, rawContent);
+    if (toolName === "Bash") {
+        for (const candidate of candidates) {
+            const hasAssistantAutoBackgrounded = typeof candidate.assistantAutoBackgrounded === "boolean";
+            const hasTokenSaverOutput = typeof candidate.tokenSaverOutput === "string" && candidate.tokenSaverOutput.length > 0;
+            if (hasAssistantAutoBackgrounded || hasTokenSaverOutput) {
+                const bashMetadata = {};
+                if (hasAssistantAutoBackgrounded) {
+                    bashMetadata.assistant_auto_backgrounded = candidate.assistantAutoBackgrounded;
+                }
+                if (hasTokenSaverOutput) {
+                    bashMetadata.token_saver_active = true;
+                }
+                return {
+                    bash: bashMetadata,
+                };
+            }
+        }
+        return undefined;
+    }
+    if (toolName === "ExitPlanMode") {
+        for (const candidate of candidates) {
+            if (typeof candidate.isUltraplan === "boolean") {
+                return { exit_plan_mode: { is_ultraplan: candidate.isUltraplan } };
+            }
+        }
+        return undefined;
+    }
+    if (toolName === "TodoWrite") {
+        for (const candidate of candidates) {
+            if (typeof candidate.verificationNudgeNeeded === "boolean") {
+                return {
+                    todo_write: { verification_nudge_needed: candidate.verificationNudgeNeeded },
+                };
+            }
+        }
+    }
+    return undefined;
+}
 export function extractText(value) {
     if (typeof value === "string") {
         return value;
@@ -255,21 +405,129 @@ function writeDiffFromResult(rawContent) {
                 : "";
         const content = typeof record.content === "string" ? record.content : "";
         const originalRaw = "originalFile" in record ? record.originalFile : "original_file" in record ? record.original_file : undefined;
+        const gitDiff = asRecordOrNull(record.gitDiff);
+        const repository = typeof gitDiff?.repository === "string" && gitDiff.repository.trim().length > 0
+            ? gitDiff.repository.trim()
+            : undefined;
         if (!filePath || !content || originalRaw === undefined) {
             continue;
         }
         const original = typeof originalRaw === "string" ? originalRaw : originalRaw === null ? "" : "";
-        return [{ type: "diff", old_path: filePath, new_path: filePath, old: original, new: content }];
+        return [
+            {
+                type: "diff",
+                old_path: filePath,
+                new_path: filePath,
+                old: original,
+                new: content,
+                ...(repository ? { repository } : {}),
+            },
+        ];
     }
     return [];
 }
-export function buildToolResultFields(isError, rawContent, base) {
-    const rawOutput = normalizeToolResultText(rawContent, isError);
+function editDiffFromResult(rawResult, rawInput) {
+    const input = asRecordOrNull(rawInput);
+    const filePath = typeof input?.file_path === "string" ? input.file_path : "";
+    const oldText = typeof input?.old_string === "string"
+        ? input.old_string
+        : typeof input?.oldString === "string"
+            ? input.oldString
+            : "";
+    const newText = typeof input?.new_string === "string"
+        ? input.new_string
+        : typeof input?.newString === "string"
+            ? input.newString
+            : "";
+    if (!filePath || (!oldText && !newText)) {
+        return [];
+    }
+    for (const candidate of resultRecordCandidates(rawResult, undefined)) {
+        const candidatePath = typeof candidate.filePath === "string"
+            ? candidate.filePath
+            : typeof candidate.file_path === "string"
+                ? candidate.file_path
+                : "";
+        const gitDiff = asRecordOrNull(candidate.gitDiff);
+        if (!candidatePath && !gitDiff) {
+            continue;
+        }
+        if (candidatePath && candidatePath !== filePath) {
+            continue;
+        }
+        const repository = typeof gitDiff?.repository === "string" && gitDiff.repository.trim().length > 0
+            ? gitDiff.repository.trim()
+            : undefined;
+        return [
+            {
+                type: "diff",
+                old_path: filePath,
+                new_path: filePath,
+                old: oldText,
+                new: newText,
+                ...(repository ? { repository } : {}),
+            },
+        ];
+    }
+    return editDiffFromInput(rawInput);
+}
+function findBashResultRecord(rawResult, rawContent) {
+    return resultRecordCandidates(rawResult, rawContent).find((candidate) => "stdout" in candidate ||
+        "stderr" in candidate ||
+        "backgroundTaskId" in candidate ||
+        "backgroundedByUser" in candidate ||
+        "assistantAutoBackgrounded" in candidate ||
+        "tokenSaverOutput" in candidate);
+}
+function bashBackgroundMessage(record) {
+    const backgroundTaskId = typeof record.backgroundTaskId === "string" ? record.backgroundTaskId : "";
+    if (!backgroundTaskId) {
+        return "";
+    }
+    if (record.assistantAutoBackgrounded === true) {
+        return `Command was auto-backgrounded by assistant mode with ID: ${backgroundTaskId}.`;
+    }
+    if (record.backgroundedByUser === true) {
+        return `Command was backgrounded by user with ID: ${backgroundTaskId}.`;
+    }
+    return `Command is running in background with ID: ${backgroundTaskId}.`;
+}
+function buildBashDisplayOutput(record) {
+    const segments = [];
+    const stdout = typeof record.stdout === "string" ? record.stdout : "";
+    const stderr = typeof record.stderr === "string" ? record.stderr : "";
+    if (stdout) {
+        segments.push(stdout);
+    }
+    if (stderr) {
+        segments.push(stderr);
+    }
+    if (record.interrupted === true) {
+        segments.push("Command was aborted before completion.");
+    }
+    const backgroundMessage = bashBackgroundMessage(record);
+    if (backgroundMessage) {
+        segments.push(backgroundMessage);
+    }
+    return segments.join("\n");
+}
+export function buildToolResultFields(isError, rawContent, base, rawResult) {
     const toolName = resolveToolName(base);
+    const bashResultRecord = toolName === "Bash" ? findBashResultRecord(rawResult, rawContent) : undefined;
+    const normalizedRawOutput = normalizeToolResultText(rawContent, isError);
+    const rawOutput = bashResultRecord
+        ? buildBashDisplayOutput(bashResultRecord)
+        : normalizedRawOutput || JSON.stringify(rawContent);
     const fields = {
         status: isError ? "failed" : "completed",
-        raw_output: rawOutput || JSON.stringify(rawContent),
     };
+    if (rawOutput) {
+        fields.raw_output = rawOutput;
+    }
+    const outputMetadata = extractToolOutputMetadata(toolName, rawResult, rawContent);
+    if (outputMetadata) {
+        fields.output_metadata = outputMetadata;
+    }
     if (!isError && toolName === "Write") {
         const structuredDiff = writeDiffFromResult(rawContent);
         if (structuredDiff.length > 0) {
@@ -283,15 +541,22 @@ export function buildToolResultFields(isError, rawContent, base) {
         }
     }
     if (!isError && toolName === "Edit") {
-        const inputDiff = editDiffFromInput(base?.raw_input);
-        if (inputDiff.length > 0) {
-            fields.content = inputDiff;
+        const structuredDiff = editDiffFromResult(rawResult, base?.raw_input);
+        if (structuredDiff.length > 0) {
+            fields.content = structuredDiff;
             return fields;
         }
         if (base?.content.some((entry) => entry.type === "diff")) {
             return fields;
         }
     }
+    if (!isError && toolName === "ReadMcpResource") {
+        const structuredResourceContent = mcpResourceContentFromResult(rawResult, rawContent);
+        if (structuredResourceContent.length > 0) {
+            fields.content = structuredResourceContent;
+            return fields;
+        }
+    }
     if (rawOutput) {
         fields.content = [{ type: "content", content: { type: "text", text: rawOutput } }];
     }