@codingame/monaco-vscode-api 37.2.0 → 37.3.0

package/vscode/src/vs/workbench/contrib/chat/browser/agentSessions/agentHost/stateToProgressAdapter.js

@@ -0,0 +1,2478 @@
+
+import { decodeBase64 } from '../../../../../../base/common/buffer.js';
+import { Codicon } from '../../../../../../base/common/codicons.js';
+import { MarkdownString, escapeMarkdownLinkLabel } from '../../../../../../base/common/htmlContent.js';
+import { escapeIcons } from '../../../../../../base/common/iconLabels.js';
+import { rewriteMarkdownLinks as rewriteMarkdownLinks$1 } from '../../../../../../base/common/markdownLinks.js';
+import { Mimes } from '../../../../../../base/common/mime.js';
+import { Schemas } from '../../../../../../base/common/network.js';
+import { win32, posix } from '../../../../../../base/common/path.js';
+import { URI } from '../../../../../../base/common/uri.js';
+import { generateUuid } from '../../../../../../base/common/uuid.js';
+import { getInlineToolInput, buildSubagentChatUri, getToolSubagentContent, readUsageInfoMeta, hasReportedUsage, readMessageSystemInitiatedLabel, isMessageRequestHiddenFromTranscript, isMessageHiddenFromTranscript, getTurnError, parseChatUri, getToolOutputText, getToolFileEdits, FileEditKind } from '../../../../../../platform/agentHost/common/state/sessionState.js';
+import { getToolKind } from '../../../../../../platform/agentHost/common/state/sessionReducers.js';
+import { readToolCallMeta } from '../../../../../../platform/agentHost/common/meta/agentToolCallMeta.js';
+import { getChatErrorDetailsFromMeta } from '../../../common/chatErrorMessages.js';
+import { createAgentHostResourceUriMapper, toAgentHostUri, toAgentHostContentUri, AGENT_HOST_SCHEME } from '../../../../../../platform/agentHost/common/agentHostUri.js';
+import { getElementAttachmentCorrelationId, AgentHostElementAttachmentDisplayKind } from '../../../../../../platform/agentHost/common/meta/agentElementAttachments.js';
+import { AgentHostAutoReplyAnswer } from '../../../../../../platform/agentHost/common/agentHostSchema.js';
+import { SessionServerToolName } from '../../../../../../platform/agentHost/common/serverToolNames.js';
+import { isAgentFeedbackAnnotationsAttachment, isAgentFeedbackAttachment, getAgentFeedbackAttachmentMetadata } from '../../../../../../platform/agentHost/common/meta/agentFeedbackAttachments.js';
+import { isBrowserViewAttachment, getBrowserViewAttachmentMetadata } from '../../../../../../platform/agentHost/common/meta/browserViewAttachments.js';
+import { readAgentMessageDelegationMeta } from '../../../../../../platform/agentHost/common/meta/agentMessageDelegationMeta.js';
+import { isAgentMergeMessage } from '../../../../../../platform/agentHost/common/meta/agentMergeMessageMeta.js';
+import { readAgentSystemNotificationMeta, AgentSystemNotificationKind, AgentSystemNotificationWorkspaceKind, AgentSystemNotificationSeverity } from '../../../../../../platform/agentHost/common/meta/agentSystemNotificationMeta.js';
+import { isAddCommentTool, isViewUnreviewedCommentsTool } from '../../../../../../platform/agentHost/common/meta/agentFeedbackAnnotations.js';
+import { buildOpenSessionLinkUri, isSendMessageTool, isCreateSessionTool, isCreateChatTool, parseOpenSessionLinkUri, parseOpenSessionLinkChatId, AGENT_HOST_SESSION_LINK_SCHEME } from '../../../../../../platform/agentHost/common/openSessionLink.js';
+import { parsePartialToolInputForDisplay } from '../../../../../../platform/agentHost/common/partialToolInput.js';
+import '../../../../../../platform/agentHost/common/state/protocol/channels-root/state.js';
+import '../../../../../../platform/agentHost/common/state/protocol/channels-session/state.js';
+import { ToolCallStatus, ToolCallCancellationReason, ChatInputAnswerState, ChatInputAnswerValueKind, ChatInputResponseKind, ChatInputQuestionKind, ToolCallContributorKind, MessageKind, ResponsePartKind, MessageAttachmentKind, ToolResultContentType, ToolCallRiskAssessmentStatus } from '../../../../../../platform/agentHost/common/state/protocol/channels-chat/state.js';
+import '../../../../../../platform/agentHost/common/state/protocol/channels-terminal/state.js';
+import '../../../../../../platform/agentHost/common/state/protocol/channels-changeset/state.js';
+import '../../../../../../platform/agentHost/common/state/protocol/channels-resource-watch/state.js';
+import '../../../../../../platform/agentHost/common/state/protocol/channels-automation/state.js';
+import '../../../../../../platform/agentHost/common/state/protocol/channels-automation-run/state.js';
+import { normalizeFileEdit } from '../../../../../../platform/agentHost/common/fileEditDiff.js';
+import '../../../../../../platform/agentHost/common/agentService.js';
+import product from '../../../../../../platform/product/common/product.js';
+import { ConfigureAutomationToolReferenceName } from '../../../common/automations/automationService.js';
+import { ElicitationState, formatCopilotCreditsLabel, ToolConfirmKind, AgentFeedbackReviewCommandId } from '../../../common/chatService/chatService.js';
+import { isTerminalCommandPrompt } from '../../../common/chatSessionsService.js';
+import { ChatToolInvocation } from '../../../common/model/chatProgressTypes/chatToolInvocation.js';
+import { ChatPlanReviewData } from '../../../common/model/chatProgressTypes/chatPlanReviewData.js';
+import { ChatQuestionCarouselData } from '../../../common/model/chatProgressTypes/chatQuestionCarouselData.js';
+import { ChatRequestOriginKind } from '../../../common/chatRequestOrigin.js';
+import { toAgentHostCompletionVariableEntryFromMetadata, restoreChatTranscriptContextVariableEntry, restorePasteVariableEntryFromAttachment, AgentHostCompletionReferenceKind } from '../../../common/attachments/chatVariableEntries.js';
+import { ToolInvocationPresentation, ToolDataSource } from '../../../common/tools/languageModelToolsService.js';
+import { isEqual, basename } from '../../../../../../base/common/resources.js';
+import { hasKey } from '../../../../../../base/common/types.js';
+import { localize } from '../../../../../../nls.js';
+import { isSessionReferenceTrajectoryAttachment, restoreSessionReferenceVariableEntryFromAttachment } from './agentHostSessionReferenceAttachment.js';
+import { restoreChatReferenceVariableEntryFromAttachment } from './agentHostChatReferenceAttachment.js';
+import { AgentSession } from '../../../../../../platform/agentHost/common/agent.js';
+
+const BOOLEAN_TRUE_OPTION_ID = "true";
+const BOOLEAN_FALSE_OPTION_ID = "false";
+const agentHostAskUserToolNames = ( new Set(["ask_user", "AskUserQuestion", "request_user_input"]));
+const imageGenerationToolName = "image_gen.imagegen";
+function isAgentHostAskUserTool(toolName) {
+    return ( agentHostAskUserToolNames.has(toolName));
+}
+function shouldHideCompletedAgentHostAskUserTool(toolCall) {
+    if (!isAgentHostAskUserTool(toolCall.toolName)) {
+        return false;
+    }
+    if (toolCall.status === ToolCallStatus.Completed) {
+        return toolCall.success;
+    }
+    return toolCall.status === ToolCallStatus.Cancelled && toolCall.reason === ToolCallCancellationReason.Skipped;
+}
+function isRenameChatTool(toolCall) {
+    return toolCall.toolName === SessionServerToolName.RenameChat || toolCall.toolName.endsWith(`__${SessionServerToolName.RenameChat}`);
+}
+function isSetWorkspaceTool(toolCall) {
+    return toolCall.toolName === SessionServerToolName.SetWorkspace || toolCall.toolName.endsWith(`__${SessionServerToolName.SetWorkspace}`);
+}
+function isAutomaticTitleRename(toolCall) {
+    if (!isRenameChatTool(toolCall) || toolCall.status === ToolCallStatus.Streaming) {
+        return false;
+    }
+    const toolInput = getInlineToolInput(toolCall.toolInput);
+    if (!toolInput) {
+        return false;
+    }
+    try {
+        const args = JSON.parse(toolInput);
+        return args.automatic === true;
+    } catch {
+        return false;
+    }
+}
+function shouldHideAutomaticTitleRename(toolCall) {
+    return isAutomaticTitleRename(toolCall) && toolCall.status !== ToolCallStatus.Cancelled && (toolCall.status !== ToolCallStatus.Completed || toolCall.success);
+}
+function makeAhpTerminalToolSessionId(terminalUri, session) {
+    return JSON.stringify({
+        terminal: terminalUri,
+        session: ( session.toString())
+    });
+}
+function parseAhpTerminalToolSessionId(id) {
+    try {
+        const parsed = JSON.parse(id);
+        if (typeof parsed?.terminal === "string" && typeof parsed?.session === "string") {
+            return parsed;
+        }
+    } catch {}
+    return undefined;
+}
+function convertProtocolAnswer(answer) {
+    if (answer.state !== ChatInputAnswerState.Submitted) {
+        return undefined;
+    }
+    switch (answer.value.kind) {
+    case ChatInputAnswerValueKind.Text:
+        return answer.value.value;
+    case ChatInputAnswerValueKind.Number:
+    case ChatInputAnswerValueKind.Boolean:
+        return String(answer.value.value);
+    case ChatInputAnswerValueKind.Selected:
+        return {
+            selectedValue: answer.value.value,
+            freeformValue: answer.value.freeformValues?.[0]
+        };
+    case ChatInputAnswerValueKind.SelectedMany:
+        return {
+            selectedValues: answer.value.value,
+            freeformValue: answer.value.freeformValues?.[0]
+        };
+    }
+}
+function convertProtocolAnswers(raw) {
+    if (!raw) {
+        return undefined;
+    }
+    const answers = {};
+    for (const [questionId, answer] of Object.entries(raw)) {
+        const converted = convertProtocolAnswer(answer);
+        if (converted !== undefined) {
+            answers[questionId] = converted;
+        }
+    }
+    return ( Object.keys(answers)).length > 0 ? answers : undefined;
+}
+function containsAutomaticReplyAnswer(raw) {
+    return ( ( Object.values(raw ?? {})).some(
+        answer => answer.state === ChatInputAnswerState.Submitted && answer.value.kind === ChatInputAnswerValueKind.Text && answer.value.value === AgentHostAutoReplyAnswer
+    ));
+}
+function getPlanReviewAction(planReview, actionId) {
+    return actionId ? planReview.actions.find(action => action.id === actionId) : undefined;
+}
+function convertProtocolPlanReviewResult(planReview, response, answers) {
+    if (response === ChatInputResponseKind.Decline) {
+        return {
+            rejected: true
+        };
+    }
+    if (response !== ChatInputResponseKind.Accept) {
+        return undefined;
+    }
+    const answer = answers?.[planReview.answerQuestionId];
+    if (!answer || answer.state === ChatInputAnswerState.Skipped) {
+        return undefined;
+    }
+    const value = answer.value;
+    if (value.kind === ChatInputAnswerValueKind.Text) {
+        const feedback = value.value.trim();
+        return feedback ? {
+            rejected: false,
+            feedback,
+            feedbackOverall: feedback
+        } : undefined;
+    }
+    if (value.kind !== ChatInputAnswerValueKind.Selected) {
+        return undefined;
+    }
+    const action = getPlanReviewAction(planReview, value.value);
+    const feedback = value.freeformValues?.find(v => v.trim().length > 0)?.trim();
+    return {
+        rejected: false,
+        action: action?.label ?? value.value,
+        actionId: action?.id ?? value.value,
+        ...(feedback ? {
+            feedback,
+            feedbackOverall: feedback
+        } : {})
+    };
+}
+function createInputRequestCarousel(inputReq, connectionAuthority) {
+    const questions = (inputReq.questions ?? []).map(question => {
+        let title = question.title;
+        let message = question.message;
+        if (!title) {
+            const endOfLine = question.message.indexOf("\n");
+            title = endOfLine === -1 ? question.message : question.message.substring(0, endOfLine).trim();
+            message = endOfLine === -1 ? "" : question.message.substring(endOfLine + 1).trim();
+        }
+        const detailedMessage = ( new MarkdownString(message, {
+            isTrusted: false
+        }));
+        switch (question.kind) {
+        case ChatInputQuestionKind.SingleSelect:
+            return {
+                id: question.id,
+                type: "singleSelect",
+                title,
+                detailedMessage,
+                required: question.required,
+                allowFreeformInput: question.allowFreeformInput ?? true,
+                options: question.options.map(option => ({
+                    id: option.id,
+                    label: option.label,
+                    value: option.id
+                }))
+            };
+        case ChatInputQuestionKind.MultiSelect:
+            return {
+                id: question.id,
+                type: "multiSelect",
+                title,
+                detailedMessage,
+                required: question.required,
+                allowFreeformInput: question.allowFreeformInput ?? true,
+                options: question.options.map(option => ({
+                    id: option.id,
+                    label: option.label,
+                    value: option.id
+                }))
+            };
+        case ChatInputQuestionKind.Boolean:
+            return {
+                id: question.id,
+                type: "singleSelect",
+                title,
+                detailedMessage,
+                required: question.required,
+                allowFreeformInput: false,
+                defaultValue: question.defaultValue === undefined ? undefined : String(question.defaultValue),
+                options: [{
+                    id: BOOLEAN_TRUE_OPTION_ID,
+                    label: ( localize(8103, "True")),
+                    value: BOOLEAN_TRUE_OPTION_ID
+                }, {
+                    id: BOOLEAN_FALSE_OPTION_ID,
+                    label: ( localize(8104, "False")),
+                    value: BOOLEAN_FALSE_OPTION_ID
+                }]
+            };
+        case ChatInputQuestionKind.Text:
+            return {
+                id: question.id,
+                type: "text",
+                title,
+                detailedMessage,
+                required: question.required,
+                defaultValue: question.defaultValue
+            };
+        default:
+            return {
+                id: question.id,
+                type: "text",
+                title,
+                detailedMessage,
+                required: question.required
+            };
+        }
+    });
+    if (questions.length === 0) {
+        questions.push({
+            id: "answer",
+            type: "text",
+            title: inputReq.message ?? "",
+            required: true
+        });
+    }
+    const carousel = ( new ChatQuestionCarouselData(
+        questions,
+        true,
+        inputReq.id,
+        undefined,
+        undefined,
+        inputReq.message ? rawMarkdownToString(inputReq.message, connectionAuthority) : undefined
+    ));
+    carousel.answerPresentation = "conversation";
+    return carousel;
+}
+function createInputRequestPlanReview(inputReq, planReview, resourceUris) {
+    return ( new ChatPlanReviewData(planReview.title, planReview.content, planReview.actions.map(action => ({
+        id: action.id,
+        label: action.label,
+        ...(action.description ? {
+            description: action.description
+        } : {}),
+        ...(action.default ? {
+            default: true
+        } : {}),
+        ...(action.permissionLevel ? {
+            permissionLevel: action.permissionLevel
+        } : {})
+    })), planReview.canProvideFeedback, planReview.planUri ? resourceUris.fromAgentHost(( URI.parse(planReview.planUri))).toJSON() : undefined, inputReq.id));
+}
+function getUrlInputRequestPresentation(inputReq, url) {
+    let authority = url;
+    try {
+        authority = ( URI.parse(url)).authority || url;
+    } catch {}
+    const message = ( new MarkdownString());
+    if (inputReq.message) {
+        message.appendText(inputReq.message);
+        message.appendMarkdown("\n\n");
+    }
+    message.appendMarkdown(( localize(8105, "Open this URL?")));
+    message.appendCodeblock("", url);
+    return {
+        authority,
+        message
+    };
+}
+function inputRequestResponsePartToProgress(
+    part,
+    connectionAuthority,
+    resourceUris = createAgentHostResourceUriMapper(connectionAuthority)
+) {
+    const inputReq = part.request;
+    const planReview = inputReq.planReview;
+    if (planReview) {
+        const review = createInputRequestPlanReview(inputReq, planReview, resourceUris);
+        review.data = part.response === undefined ? undefined : convertProtocolPlanReviewResult(planReview, part.response, inputReq.answers);
+        review.isUsed = true;
+        return review;
+    }
+    if (inputReq.url) {
+        const presentation = getUrlInputRequestPresentation(inputReq, inputReq.url);
+        return {
+            kind: "elicitationSerialized",
+            title: ( localize(8106, "Authorization Required")),
+            message: presentation.message,
+            subtitle: "",
+            source: undefined,
+            state: part.response === ChatInputResponseKind.Accept ? ElicitationState.Accepted : ElicitationState.Rejected,
+            isHidden: false
+        };
+    }
+    const carousel = createInputRequestCarousel(inputReq, connectionAuthority);
+    const answers = part.response === ChatInputResponseKind.Accept ? convertProtocolAnswers(inputReq.answers) : undefined;
+    carousel.data = answers ?? {};
+    carousel.isUsed = true;
+    carousel.autoReply = containsAutomaticReplyAnswer(inputReq.answers);
+    carousel.answeredExternally = part.response === ChatInputResponseKind.Accept && (carousel.autoReply || !answers);
+    return carousel;
+}
+function getSubagentTaskDescription(tc) {
+    const v = readToolCallMeta(tc).subagentDescription;
+    return v && v.length > 0 ? v : undefined;
+}
+function getSubagentAgentName(tc) {
+    const v = readToolCallMeta(tc).subagentAgentName;
+    return v && v.length > 0 ? v : undefined;
+}
+function applyToolCallProgress(invocation, tc) {
+    const progressMessage = tc.status === ToolCallStatus.Running ? readToolCallMeta(tc).progressMessage : undefined;
+    if (progressMessage !== undefined) {
+        invocation.acceptProgress({
+            message: progressMessage
+        });
+    }
+}
+function getSubagentChatResource(tc, subagentContent, sessionResource) {
+    return readToolCallMeta(tc).subagentChatUri ?? subagentContent?.resource ?? buildSubagentChatUri(( sessionResource.toString()), tc.toolCallId);
+}
+function getSubagentToolSpecificData(tc, sessionResource) {
+    const subagentContent = (tc.status === ToolCallStatus.Running || tc.status === ToolCallStatus.Completed) ? getToolSubagentContent(tc) : undefined;
+    if (!isSubagentTool(tc) && !subagentContent) {
+        return undefined;
+    }
+    return {
+        kind: "subagent",
+        hasStarted: false,
+        description: getSubagentTaskDescription(tc),
+        ...(subagentContent?.title ? {
+            agentDisplayName: subagentContent.title
+        } : {}),
+        agentName: subagentContent?.agentName ?? getSubagentAgentName(tc),
+        chatResource: getSubagentChatResource(tc, subagentContent, sessionResource),
+        isChatAvailable: false
+    };
+}
+function getMcpAppData(tc, connectionAuthority) {
+    if (tc.contributor?.kind !== ToolCallContributorKind.MCP) {
+        return undefined;
+    }
+    const ui = readToolCallMeta(tc).ui;
+    if (!ui) {
+        return undefined;
+    }
+    const resourceUri = ui.resourceUri;
+    const channelValue = ui.channel;
+    if (channelValue === undefined) {
+        return undefined;
+    }
+    return {
+        kind: "agentHost",
+        resourceUri,
+        connectionAuthority,
+        serverId: tc.contributor.customizationId,
+        channel: channelValue
+    };
+}
+function getToolRawInput(tc) {
+    const toolInput = tc.status === ToolCallStatus.Streaming ? undefined : getInlineToolInput(tc.toolInput);
+    try {
+        return toolInput ? JSON.parse(toolInput) : {};
+    } catch {
+        return {
+            input: toolInput
+        };
+    }
+}
+function buildMcpAppToolInputData(tc, connectionAuthority, existingRawInput) {
+    const mcpAppData = getMcpAppData(tc, connectionAuthority);
+    if (!mcpAppData) {
+        return undefined;
+    }
+    return {
+        kind: "input",
+        rawInput: existingRawInput ?? getToolRawInput(tc),
+        mcpAppData
+    };
+}
+function isSameMcpAppData(a, b) {
+    if (a?.kind !== b?.kind || a?.resourceUri !== b?.resourceUri) {
+        return false;
+    }
+    if (a?.kind === "agentHost" && b?.kind === "agentHost") {
+        return a.serverId === b.serverId && a.channel === b.channel && a.connectionAuthority === b.connectionAuthority;
+    }
+    if (a?.kind === "local" && b?.kind === "local") {
+        return a.serverDefinitionId === b.serverDefinitionId && a.collectionId === b.collectionId;
+    }
+    return a === b;
+}
+const SUBAGENT_TOOL_NAMES = ( new Set(["task"]));
+function isSubagentToolName(toolName) {
+    return ( SUBAGENT_TOOL_NAMES.has(toolName));
+}
+function systemNotificationToChatPart(content, connectionAuthority, _meta) {
+    if (!content) {
+        return undefined;
+    }
+    const value = stringOrMarkdownToString(content, connectionAuthority);
+    const markdown = typeof value === "string" ? ( new MarkdownString(value)) : value;
+    const meta = readAgentSystemNotificationMeta({
+        _meta
+    });
+    switch (meta.kind) {
+    case AgentSystemNotificationKind.WorktreeCreationFailure:
+        return meta.severity === AgentSystemNotificationSeverity.Warning ? {
+            kind: "warning",
+            content: markdown
+        } : {
+            kind: "systemNotification",
+            content: markdown
+        };
+    case AgentSystemNotificationKind.WorkspaceTransition:
+        if (!meta.workspaceName || !meta.workspaceKind) {
+            return {
+                kind: "systemNotification",
+                content: markdown
+            };
+        }
+        return {
+            kind: "systemNotification",
+            content: markdown,
+            icon: meta.workspaceKind === AgentSystemNotificationWorkspaceKind.Worktree ? Codicon.worktreeCompact : Codicon.folderCompact,
+            presentation: "workspaceTransition",
+            workspaceName: meta.workspaceName,
+            accessibilityLabel: meta.workspaceKind === AgentSystemNotificationWorkspaceKind.Worktree ? ( localize(
+                8107,
+                "Workspace changed. This session is now working in {0} using an isolated worktree.",
+                meta.workspaceName
+            )) : ( localize(
+                8108,
+                "Workspace changed. This session is now working directly in {0}.",
+                meta.workspaceName
+            ))
+        };
+    case AgentSystemNotificationKind.AutomaticApprovalReviewTimedOut:
+        return {
+            kind: "systemNotification",
+            content: markdown,
+            icon: Codicon.clock,
+            collapsible: true
+        };
+    case AgentSystemNotificationKind.AutomaticApprovalReviewAborted:
+        return {
+            kind: "systemNotification",
+            content: markdown,
+            icon: Codicon.circleSlash,
+            collapsible: true
+        };
+    case AgentSystemNotificationKind.AutomaticApprovalReviewInterrupted:
+        return {
+            kind: "systemNotification",
+            content: markdown,
+            icon: Codicon.warning
+        };
+    case AgentSystemNotificationKind.AgentMergeEnabled:
+        return {
+            kind: "systemNotification",
+            content: markdown,
+            icon: Codicon.gitMerge,
+            collapsible: true,
+            renderInlineTiming: true
+        };
+    case AgentSystemNotificationKind.AgentMergeConfigurationChanged:
+        return {
+            kind: "systemNotification",
+            content: markdown,
+            icon: Codicon.settingsGear,
+            collapsible: true,
+            renderInlineTiming: true
+        };
+    case AgentSystemNotificationKind.AgentMergeDisabled:
+        return {
+            kind: "systemNotification",
+            content: markdown,
+            icon: Codicon.circleSlash,
+            renderInlineTiming: true
+        };
+    case AgentSystemNotificationKind.AgentMergePullRequestMerged:
+        return {
+            kind: "systemNotification",
+            content: markdown,
+            icon: Codicon.gitMerge,
+            renderInlineTiming: true
+        };
+    default:
+        return {
+            kind: "systemNotification",
+            content: markdown
+        };
+    }
+}
+function isSubagentTool(tc) {
+    return getToolKind(tc) === "subagent" || isSubagentToolName(tc.toolName);
+}
+function shouldObserveSubagentChat(tc, hasCatalogChild = false) {
+    if (hasCatalogChild) {
+        return true;
+    }
+    const hasSubagentContent = (tc.status === ToolCallStatus.Running || tc.status === ToolCallStatus.Completed) && getToolSubagentContent(tc) !== undefined;
+    if (tc.status === ToolCallStatus.Running) {
+        return isSubagentTool(tc) || hasSubagentContent;
+    }
+    return tc.status === ToolCallStatus.Completed && (hasSubagentContent || (tc.success && isSubagentTool(tc)));
+}
+function getTerminalContentUri(content) {
+    return getTerminalContent(content)?.resource;
+}
+function getTerminalContent(content) {
+    return content?.find(isToolResultTerminalContent);
+}
+function formatTurnResponseDetails(model, billedModelId, usage) {
+    if (!model) {
+        return undefined;
+    }
+    const displayName = formatTurnModelName(model, billedModelId);
+    const credits = usageInfoToChatUsage(usage)?.copilotCredits;
+    if (credits !== undefined) {
+        return [displayName, formatCopilotCreditsLabel(credits)].join(" • ");
+    }
+    return [displayName, model.pricing].filter(Boolean).join(" · ");
+}
+function usageInfoToAutoModeResolution(usage, resolvedModelName) {
+    const resolution = readUsageInfoMeta(usage).autoModeResolved;
+    if (!resolution) {
+        return undefined;
+    }
+    return {
+        kind: "autoModeResolution",
+        resolved: {
+            id: resolution.chosenModel,
+            name: resolvedModelName ?? resolution.chosenModel
+        }
+    };
+}
+function formatTurnModelName(model, billedModelId) {
+    if (billedModelId) {
+        return localize(8109, "{0} ({1})", model.name, billedModelId);
+    }
+    return model.name;
+}
+function usageInfoToChatUsage(usage, modelDisplayNameResolver) {
+    if (!hasReportedUsage(usage)) {
+        return undefined;
+    }
+    const turnTokenTotals = readUsageInfoMeta(usage).turnTokenTotals;
+    return {
+        kind: "usage",
+        promptTokens: usage?.inputTokens ?? 0,
+        completionTokens: usage?.outputTokens ?? 0,
+        copilotCredits: getCopilotCredits(usage),
+        sessionCopilotCredits: getSessionCopilotCredits(usage),
+        promptTokenDetails: contextAttributionToPromptTokenDetails(usage),
+        modelTotals: turnTokenTotals?.map(total => ({
+            ...total,
+            model: modelDisplayNameResolver?.(total.model) ?? total.model
+        }))
+    };
+}
+function getSessionCopilotCredits(usage) {
+    const sessionTotalNanoAiu = readUsageInfoMeta(usage).copilotUsage?.sessionTotalNanoAiu;
+    return typeof sessionTotalNanoAiu === "number" && sessionTotalNanoAiu >= 0 ? sessionTotalNanoAiu / 1_000_000_000 : undefined;
+}
+function getCopilotCredits(usage) {
+    const meta = readUsageInfoMeta(usage);
+    const totalNanoAiu = meta?.copilotUsage?.totalNanoAiu;
+    if (typeof totalNanoAiu === "number" && totalNanoAiu >= 0) {
+        return totalNanoAiu / 1_000_000_000;
+    }
+    const cost = meta?.cost;
+    return typeof cost === "number" && cost >= 0 ? cost : undefined;
+}
+function kindToCategory(kind) {
+    switch (kind) {
+    case "system":
+    case "toolDefinition":
+        return localize(8110, "System");
+    case "tool":
+    case "skill":
+    case "subagent":
+    case "mcpServer":
+    case "plugin":
+        return localize(8111, "User Context");
+    default:
+        return localize(8111, "User Context");
+    }
+}
+function kindToAggregateLabel(kind) {
+    switch (kind) {
+    case "tool":
+        return localize(8112, "Tool Results");
+    case "toolDefinition":
+        return localize(8113, "Tool Definitions");
+    case "skill":
+        return localize(8114, "Skills");
+    case "subagent":
+        return localize(8115, "Sub-agents");
+    case "mcpServer":
+        return localize(8116, "MCP Tools");
+    case "plugin":
+        return localize(8117, "Plugins");
+    default:
+        return kind;
+    }
+}
+function contextAttributionToPromptTokenDetails(usage) {
+    const meta = readUsageInfoMeta(usage);
+    const attribution = meta?.contextAttribution;
+    if (!attribution || attribution.totalTokens <= 0 || attribution.entries.length === 0) {
+        return undefined;
+    }
+    const details = [];
+    const parentIds = ( new Set());
+    for (const entry of attribution.entries) {
+        if (entry.parentId) {
+            parentIds.add(entry.parentId);
+        }
+    }
+    const kindTokens = ( new Map());
+    let accountedTokens = 0;
+    for (const entry of attribution.entries) {
+        if (entry.kind === "system") {
+            if (( parentIds.has(entry.id))) {
+                continue;
+            }
+            accountedTokens += entry.tokens;
+            const percentageOfPrompt = Math.round((entry.tokens / attribution.totalTokens) * 100);
+            if (percentageOfPrompt > 0) {
+                details.push({
+                    category: kindToCategory("system"),
+                    label: entry.label,
+                    percentageOfPrompt
+                });
+            }
+        } else {
+            kindTokens.set(entry.kind, (kindTokens.get(entry.kind) ?? 0) + entry.tokens);
+        }
+    }
+    for (const [kind, tokens] of kindTokens) {
+        accountedTokens += tokens;
+        const percentageOfPrompt = Math.round((tokens / attribution.totalTokens) * 100);
+        if (percentageOfPrompt <= 0) {
+            continue;
+        }
+        const category = kindToCategory(kind);
+        const label = kindToAggregateLabel(kind);
+        details.push({
+            category,
+            label,
+            percentageOfPrompt
+        });
+    }
+    const messageTokens = Math.max(0, attribution.totalTokens - accountedTokens);
+    if (messageTokens > 0) {
+        const percentageOfPrompt = Math.round((messageTokens / attribution.totalTokens) * 100);
+        if (percentageOfPrompt > 0) {
+            details.push({
+                category: ( localize(8111, "User Context")),
+                label: ( localize(8118, "Messages")),
+                percentageOfPrompt
+            });
+        }
+    }
+    return details.length > 0 ? details : undefined;
+}
+function mapAccountQuotaSnapshot(snapshot) {
+    const unlimited = snapshot.isUnlimitedEntitlement ?? false;
+    const entitlement = typeof snapshot.entitlementRequests === "number" ? snapshot.entitlementRequests : undefined;
+    if (!unlimited && entitlement === 0) {
+        return undefined;
+    }
+    if (typeof snapshot.remainingPercentage !== "number") {
+        return undefined;
+    }
+    const used = typeof snapshot.usedRequests === "number" ? snapshot.usedRequests : undefined;
+    const resetAtMs = snapshot.resetDate ? Date.parse(snapshot.resetDate) : NaN;
+    return {
+        percentRemaining: Math.min(100, Math.max(0, snapshot.remainingPercentage)),
+        unlimited,
+        usageBasedBilling: snapshot.tokenBasedBilling,
+        entitlement: !unlimited && entitlement !== undefined && entitlement >= 0 ? entitlement : undefined,
+        quotaRemaining: !unlimited && entitlement !== undefined && used !== undefined ? Math.max(0, entitlement - used) : undefined,
+        resetAt: Number.isFinite(resetAtMs) ? Math.floor(resetAtMs / 1000) : undefined
+    };
+}
+function mapRateLimitSnapshot(snapshot) {
+    if (!snapshot || typeof snapshot.remainingPercentage !== "number") {
+        return undefined;
+    }
+    return {
+        percentRemaining: Math.min(100, Math.max(0, snapshot.remainingPercentage)),
+        unlimited: snapshot.isUnlimitedEntitlement ?? false,
+        resetDate: snapshot.resetDate
+    };
+}
+function usageInfoToQuotas(usage) {
+    const meta = readUsageInfoMeta(usage);
+    const snapshots = meta?.quotaSnapshots;
+    if (!snapshots) {
+        return undefined;
+    }
+    const update = {};
+    let hasAny = false;
+    const chatRaw = snapshots["chat"];
+    const chat = chatRaw && mapAccountQuotaSnapshot(chatRaw);
+    if (chat) {
+        update.chat = chat;
+        hasAny = true;
+    }
+    const completions = snapshots["completions"] && mapAccountQuotaSnapshot(snapshots["completions"]);
+    if (completions) {
+        update.completions = completions;
+        hasAny = true;
+    }
+    const premiumRaw = snapshots["premium_models"] ?? snapshots["premium_interactions"];
+    const premiumChat = premiumRaw && mapAccountQuotaSnapshot(premiumRaw);
+    if (premiumChat) {
+        update.premiumChat = premiumChat;
+        hasAny = true;
+    }
+    if (premiumRaw) {
+        update.additionalUsageEnabled = premiumRaw.overageAllowedWithExhaustedQuota ?? false;
+        update.additionalUsageCount = typeof premiumRaw.overage === "number" ? premiumRaw.overage : 0;
+        if (typeof premiumRaw.overageEntitlement === "number") {
+            update.additionalUsageEntitlement = premiumRaw.overageEntitlement;
+        }
+        hasAny = true;
+    }
+    const usageBasedBilling = premiumRaw?.tokenBasedBilling ?? chatRaw?.tokenBasedBilling;
+    if (usageBasedBilling !== undefined) {
+        update.usageBasedBilling = usageBasedBilling;
+        hasAny = true;
+    }
+    const sessionRateLimit = mapRateLimitSnapshot(snapshots["session"]);
+    if (sessionRateLimit) {
+        update.sessionRateLimit = sessionRateLimit;
+        hasAny = true;
+    }
+    const weeklyRateLimit = mapRateLimitSnapshot(snapshots["weekly"]);
+    if (weeklyRateLimit) {
+        update.weeklyRateLimit = weeklyRateLimit;
+        hasAny = true;
+    }
+    const resetDate = premiumRaw?.resetDate ?? chatRaw?.resetDate;
+    if (resetDate) {
+        update.resetDate = resetDate;
+    }
+    return hasAny ? update : undefined;
+}
+function turnsToHistory(
+    backendSession,
+    turns,
+    participantId,
+    connectionAuthority,
+    lookup,
+    errorContext,
+    terminalCommandPrefix,
+    resourceUris = createAgentHostResourceUriMapper(connectionAuthority),
+    logicalSessionScheme = backendSession.scheme,
+    errorDetailsProvider
+) {
+    const history = [];
+    for (const turn of turns) {
+        const rawModelId = turn.usage?.model;
+        const modelId = lookup?.toLanguageModelId(rawModelId);
+        const details = lookup?.toResponseDetails(rawModelId, turn.usage);
+        const variableData = messageToVariableData(turn.message, connectionAuthority);
+        const origin = messageToRequestOrigin(backendSession, turn.message, participantId, logicalSessionScheme);
+        const isSystemInitiated = turn.message.origin.kind === MessageKind.SystemNotification;
+        const requestSource = messageToRequestSource(turn.message);
+        const isTerminalRequest = isTerminalCommandPrompt(turn.message.text, terminalCommandPrefix);
+        history.push({
+            id: turn.id,
+            type: "request",
+            prompt: turn.message.text,
+            participant: participantId,
+            modelId,
+            ...(turn.startedAt !== undefined && Number.isFinite(Date.parse(turn.startedAt)) ? {
+                timestamp: Date.parse(turn.startedAt)
+            } : {}),
+            variableData,
+            ...(isMessageHiddenFromTranscript(turn.message) ? {
+                isHidden: true
+            } : {}),
+            ...(isMessageRequestHiddenFromTranscript(turn.message) ? {
+                isRequestHidden: true
+            } : {}),
+            ...(isSystemInitiated ? {
+                isSystemInitiated: true,
+                systemInitiatedLabel: readMessageSystemInitiatedLabel(turn.message)
+            } : {}),
+            ...(requestSource !== undefined ? {
+                requestSource
+            } : {}),
+            ...(isTerminalRequest ? {
+                isTerminalRequest: true
+            } : {}),
+            ...(origin ? {
+                origin
+            } : {})
+        });
+        const parts = [];
+        const autoModeResolution = lookup?.toAutoModeResolution?.(turn.usage);
+        if (autoModeResolution?.resolved) {
+            parts.push(autoModeResolution);
+        }
+        const usage = usageInfoToChatUsage(turn.usage, lookup?.toModelDisplayName);
+        if (usage) {
+            parts.push(usage);
+        }
+        for (const rp of turn.responseParts) {
+            switch (rp.kind) {
+            case ResponsePartKind.Markdown:
+                if (rp.content) {
+                    parts.push({
+                        kind: "markdownContent",
+                        content: ( new MarkdownString(rp.content))
+                    });
+                }
+                break;
+            case ResponsePartKind.ToolCall:
+                {
+                    const tc = rp.toolCall;
+                    const fileEditParts = completedToolCallToEditParts(tc, connectionAuthority);
+                    const serialized = completedToolCallToSerialized(tc, undefined, backendSession, connectionAuthority, resourceUris);
+                    if (fileEditParts.length > 0) {
+                        serialized.presentation = ToolInvocationPresentation.Hidden;
+                    }
+                    parts.push(serialized);
+                    parts.push(...fileEditParts);
+                    break;
+                }
+            case ResponsePartKind.Reasoning:
+                if (rp.content) {
+                    parts.push({
+                        kind: "thinking",
+                        value: rp.content,
+                        id: rp.id
+                    });
+                }
+                break;
+            case ResponsePartKind.SystemNotification:
+                {
+                    const progress = systemNotificationToChatPart(rp.content, connectionAuthority, rp._meta);
+                    if (progress) {
+                        parts.push(progress);
+                    }
+                }
+                break;
+            case ResponsePartKind.ContentRef:
+                break;
+            case ResponsePartKind.InputRequest:
+                {
+                    parts.push(inputRequestResponsePartToProgress(rp, connectionAuthority, resourceUris));
+                    break;
+                }
+            }
+        }
+        let errorDetails;
+        const turnError = getTurnError(turn);
+        if (turnError) {
+            errorDetails = errorDetailsProvider?.(turn) ?? getChatErrorDetailsFromMeta(turnError, errorContext) ?? {
+                message: `Error: (${turnError.errorType}) ${turnError.message}`
+            };
+        }
+        const startedAt = turn.startedAt === undefined ? undefined : Date.parse(turn.startedAt);
+        const completedAt = startedAt !== undefined && Number.isFinite(startedAt) && typeof turn.duration === "number" && Number.isFinite(turn.duration) && turn.duration >= 0 ? startedAt + turn.duration : undefined;
+        history.push({
+            type: "response",
+            parts,
+            participant: participantId,
+            details,
+            elapsedMs: turn.duration,
+            completedAt,
+            ...(errorDetails ? {
+                errorDetails
+            } : {})
+        });
+    }
+    return history;
+}
+function messageToRequestSource(message) {
+    if (message.origin.kind === MessageKind.SystemNotification && isAgentMergeMessage(message)) {
+        return "agentMerge";
+    }
+    return undefined;
+}
+function messageToRequestOrigin(
+    backendSession,
+    message,
+    participantId,
+    logicalSessionScheme = backendSession.scheme
+) {
+    const delegation = readAgentMessageDelegationMeta(message);
+    if (!delegation) {
+        return undefined;
+    }
+    if (hasKey(delegation, {
+        sourceSession: true
+    })) {
+        const sourceSession = ( URI.parse(delegation.sourceSession));
+        const logicalSourceSession = sourceSession.scheme === backendSession.scheme ? sourceSession.with({
+            scheme: logicalSessionScheme
+        }) : sourceSession;
+        return {
+            kind: ChatRequestOriginKind.Delegation,
+            sourceSessionResource: ( URI.parse(buildOpenSessionLinkUri(
+                logicalSourceSession,
+                delegation.sourceChat ? parseChatUri(delegation.sourceChat)?.chatId : undefined,
+                delegation.sourceTurnId
+            ))),
+            delegationScope: isEqual(sourceSession, backendSession) ? "chat" : "session"
+        };
+    }
+    if (delegation.sourceThreadId === AgentSession.id(backendSession)) {
+        return undefined;
+    }
+    return {
+        kind: ChatRequestOriginKind.Delegation,
+        sourceSessionResource: AgentSession.uri(participantId, delegation.sourceThreadId)
+    };
+}
+function messageToVariableData(message, connectionAuthority) {
+    return messageAttachmentsToVariableData(message.attachments, connectionAuthority, message.text);
+}
+function messageAttachmentsToVariableData(attachments, connectionAuthority, messageText) {
+    if (!attachments?.length) {
+        return undefined;
+    }
+    const variables = [];
+    const aggregatedFeedback = aggregateAgentFeedbackAttachments(attachments, connectionAuthority);
+    if (aggregatedFeedback) {
+        variables.push(aggregatedFeedback);
+    }
+    const consumedAttachments = ( new Set());
+    for (const a of attachments) {
+        if ((aggregatedFeedback && isAgentFeedbackMessageAttachment(a)) || ( consumedAttachments.has(a))) {
+            continue;
+        }
+        const element = restoreElementVariableEntry(
+            a,
+            a.type === MessageAttachmentKind.Simple ? a.modelRepresentation : undefined
+        );
+        if (element) {
+            const correlationId = getElementAttachmentCorrelationId(a);
+            const imageAttachment = correlationId ? attachments.find(
+                candidate => candidate.displayKind === "image" && getElementAttachmentCorrelationId(candidate) === correlationId
+            ) : undefined;
+            const image = imageAttachment ? messageAttachmentToVariableEntry(imageAttachment, connectionAuthority) : undefined;
+            if (imageAttachment && image?.kind === "image") {
+                consumedAttachments.add(imageAttachment);
+            }
+            variables.push(image?.kind === "image" ? {
+                ...element,
+                imageData: image.value instanceof Uint8Array || URI.isUri(image.value) ? image.value : undefined,
+                imageMimeType: image.mimeType
+            } : element);
+            continue;
+        }
+        const v = messageAttachmentToVariableEntry(a, connectionAuthority, messageText);
+        if (v) {
+            variables.push(v);
+        }
+    }
+    return variables.length > 0 ? {
+        variables
+    } : undefined;
+}
+function isAgentFeedbackMessageAttachment(attachment) {
+    return isAgentFeedbackAnnotationsAttachment(attachment) || isAgentFeedbackAttachment(attachment);
+}
+function aggregateAgentFeedbackAttachments(attachments, connectionAuthority) {
+    const feedbackAttachments = attachments.filter(isAgentFeedbackMessageAttachment);
+    if (feedbackAttachments.length === 0 || (feedbackAttachments.length === 1 && isAgentFeedbackAttachment(feedbackAttachments[0]))) {
+        return undefined;
+    }
+    let sessionResource;
+    let annotationsResource;
+    const feedbackItems = ( new Map());
+    for (const attachment of feedbackAttachments) {
+        if (attachment.type === MessageAttachmentKind.Annotations) {
+            annotationsResource ??= attachment.resource;
+        }
+        const metadata = getAgentFeedbackAttachmentMetadata(attachment);
+        if (!metadata) {
+            continue;
+        }
+        sessionResource ??= metadata.sessionResource;
+        for (const item of metadata.feedbackItems) {
+            feedbackItems.set(item.id, {
+                id: item.id,
+                text: item.text,
+                resourceUri: toAgentHostUri(( URI.parse(item.resourceUri)), connectionAuthority),
+                range: textRangeToIRange(item.range),
+                ...(item.replies?.length ? {
+                    replies: item.replies
+                } : {})
+            });
+        }
+    }
+    const firstAttachment = feedbackAttachments[0];
+    if (feedbackItems.size === 0 || !sessionResource) {
+        return {
+            kind: "generic",
+            id: generateUuid(),
+            name: firstAttachment.label,
+            value: firstAttachment.type === MessageAttachmentKind.Simple ? firstAttachment.modelRepresentation || firstAttachment.label : firstAttachment.label,
+            _meta: firstAttachment._meta
+        };
+    }
+    return {
+        kind: "agentFeedback",
+        id: generateUuid(),
+        name: feedbackItems.size === 1 ? ( localize(8119, "1 comment")) : ( localize(8120, "{0} comments", feedbackItems.size)),
+        value: firstAttachment.type === MessageAttachmentKind.Simple ? firstAttachment.modelRepresentation || firstAttachment.label : firstAttachment.label,
+        sessionResource: ( URI.parse(sessionResource)),
+        annotationsResource: annotationsResource ? ( URI.parse(annotationsResource)) : undefined,
+        feedbackItems: [...( feedbackItems.values())],
+        _meta: firstAttachment._meta
+    };
+}
+function messageAttachmentToVariableEntry(attachment, connectionAuthority, messageText) {
+    if (isAgentFeedbackAttachment(attachment)) {
+        const metadata = getAgentFeedbackAttachmentMetadata(attachment);
+        if (metadata) {
+            return {
+                kind: "agentFeedback",
+                id: generateUuid(),
+                name: attachment.label,
+                value: attachment.modelRepresentation || attachment.label,
+                sessionResource: ( URI.parse(metadata.sessionResource)),
+                feedbackItems: metadata.feedbackItems.map(item => ({
+                    id: item.id,
+                    text: item.text,
+                    resourceUri: toAgentHostUri(( URI.parse(item.resourceUri)), connectionAuthority),
+                    range: textRangeToIRange(item.range)
+                })),
+                _meta: attachment._meta
+            };
+        }
+    }
+    if (attachment.type === MessageAttachmentKind.Resource) {
+        if (isSessionReferenceTrajectoryAttachment(attachment)) {
+            return undefined;
+        }
+        const uri = toAgentHostUri(( URI.parse(attachment.uri)), connectionAuthority);
+        const name = attachment.label;
+        const id = ( uri.toString()) + (attachment.selection ? `:${attachment.selection.range.start.line}-${attachment.selection.range.end.line}` : "");
+        const _meta = attachment._meta;
+        if (attachment.displayKind === "directory") {
+            return {
+                kind: "directory",
+                id,
+                name,
+                value: uri,
+                _meta
+            };
+        }
+        if (attachment.displayKind === "image") {
+            return {
+                kind: "image",
+                id,
+                name,
+                value: uri,
+                isURL: true,
+                references: [{
+                    kind: "reference",
+                    reference: uri
+                }],
+                _meta
+            };
+        }
+        if (attachment.selection) {
+            return {
+                kind: "file",
+                id,
+                name,
+                value: {
+                    uri,
+                    range: textRangeToIRange(attachment.selection.range)
+                },
+                _meta
+            };
+        }
+        return {
+            kind: "file",
+            id,
+            name,
+            value: uri,
+            _meta
+        };
+    }
+    if (attachment.type === MessageAttachmentKind.EmbeddedResource) {
+        if (!attachment.contentType.startsWith("image/")) {
+            return {
+                kind: "generic",
+                id: generateUuid(),
+                name: attachment.label,
+                value: decodeBase64(attachment.data).buffer,
+                _meta: attachment._meta
+            };
+        }
+        return {
+            kind: "image",
+            id: generateUuid(),
+            name: attachment.label || "image",
+            value: decodeBase64(attachment.data).buffer,
+            mimeType: attachment.contentType,
+            isURL: false,
+            _meta: attachment._meta
+        };
+    }
+    if (attachment.type === MessageAttachmentKind.Chat) {
+        return restoreChatReferenceVariableEntryFromAttachment(attachment, messageText);
+    }
+    const agentHostCompletionKind = getAgentHostCompletionKind(attachment);
+    if (agentHostCompletionKind !== undefined) {
+        return toAgentHostCompletionVariableEntryFromMetadata(agentHostCompletionKind, attachment.label, attachment._meta);
+    }
+    const modelRepresentation = attachment.type === MessageAttachmentKind.Simple ? attachment.modelRepresentation : undefined;
+    if (isBrowserViewAttachment(attachment) && modelRepresentation !== undefined) {
+        const metadata = getBrowserViewAttachmentMetadata(attachment);
+        if (metadata) {
+            return {
+                kind: "browserView",
+                id: metadata.browserUri,
+                name: attachment.label,
+                value: ( URI.parse(metadata.browserUri)),
+                browserId: metadata.browserId,
+                modelDescription: modelRepresentation,
+                _meta: attachment._meta
+            };
+        }
+    }
+    if (attachment.type === MessageAttachmentKind.Simple && modelRepresentation !== undefined) {
+        const transcriptContextEntry = restoreChatTranscriptContextVariableEntry(attachment.label, modelRepresentation, attachment._meta);
+        if (transcriptContextEntry) {
+            return transcriptContextEntry;
+        }
+    }
+    if (attachment.displayKind === "workspace" && modelRepresentation !== undefined) {
+        return {
+            kind: "workspace",
+            id: attachment.label,
+            name: attachment.label,
+            value: modelRepresentation,
+            _meta: attachment._meta
+        };
+    }
+    if (attachment.type === MessageAttachmentKind.Simple) {
+        const sessionReferenceEntry = restoreSessionReferenceVariableEntryFromAttachment(attachment);
+        if (sessionReferenceEntry) {
+            return sessionReferenceEntry;
+        }
+    }
+    const pasteEntry = restorePasteVariableEntryFromAttachment({
+        label: attachment.label,
+        modelRepresentation,
+        _meta: attachment._meta
+    });
+    if (pasteEntry) {
+        return pasteEntry;
+    }
+    return {
+        kind: "generic",
+        id: generateUuid(),
+        name: attachment.label,
+        value: modelRepresentation || attachment.label,
+        _meta: attachment._meta
+    };
+}
+function restoreElementVariableEntry(attachment, modelRepresentation) {
+    if (attachment.displayKind !== AgentHostElementAttachmentDisplayKind || modelRepresentation === undefined) {
+        return undefined;
+    }
+    const fullName = /^Element:\s*(?<name>.+)$/m.exec(modelRepresentation)?.groups?.name;
+    return {
+        kind: "element",
+        id: generateUuid(),
+        name: attachment.label,
+        ...(fullName ? {
+            fullName
+        } : {}),
+        icon: Codicon.layout,
+        value: modelRepresentation,
+        _meta: attachment._meta
+    };
+}
+function getAgentHostCompletionKind(attachment) {
+    if (attachment.type !== MessageAttachmentKind.Simple) {
+        return undefined;
+    }
+    switch (attachment.displayKind) {
+    case "command":
+        return AgentHostCompletionReferenceKind.Command;
+    case "skill":
+        return AgentHostCompletionReferenceKind.Skill;
+    }
+    return undefined;
+}
+function textRangeToIRange(range) {
+    return {
+        startLineNumber: range.start.line + 1,
+        startColumn: range.start.character + 1,
+        endLineNumber: range.end.line + 1,
+        endColumn: range.end.character + 1
+    };
+}
+function activeTurnToProgress(
+    sessionResource,
+    activeTurn,
+    connectionAuthority,
+    mcpServerAuthority = sessionResource.authority,
+    toolInvocationOptions,
+    lookup,
+    resourceUris = createAgentHostResourceUriMapper(connectionAuthority),
+    subagentToolCallIds
+) {
+    const parts = [];
+    const usage = usageInfoToChatUsage(activeTurn.usage, lookup?.toModelDisplayName);
+    if (usage) {
+        parts.push(usage);
+    }
+    for (const rp of activeTurn.responseParts) {
+        switch (rp.kind) {
+        case ResponsePartKind.Markdown:
+            if (rp.content) {
+                parts.push({
+                    kind: "markdownContent",
+                    content: ( new MarkdownString(rp.content))
+                });
+            }
+            break;
+        case ResponsePartKind.Reasoning:
+            if (rp.content) {
+                parts.push({
+                    kind: "thinking",
+                    value: rp.content,
+                    id: rp.id
+                });
+            }
+            break;
+        case ResponsePartKind.ToolCall:
+            {
+                const tc = rp.toolCall;
+                const isOtherClientToolCall = tc.contributor?.kind === ToolCallContributorKind.Client && toolInvocationOptions && tc.contributor.clientId !== toolInvocationOptions.currentClientId;
+                if (tc.status === ToolCallStatus.Completed || tc.status === ToolCallStatus.Cancelled) {
+                    if (shouldObserveSubagentChat(tc, subagentToolCallIds?.has(tc.toolCallId))) {
+                        const invocation = toolCallStateToInvocation(
+                            tc,
+                            undefined,
+                            sessionResource,
+                            connectionAuthority,
+                            mcpServerAuthority,
+                            toolInvocationOptions,
+                            resourceUris
+                        );
+                        finalizeToolInvocation(invocation, tc, sessionResource, connectionAuthority, resourceUris);
+                        parts.push(invocation);
+                    } else {
+                        parts.push(
+                            completedToolCallToSerialized(tc, undefined, sessionResource, connectionAuthority, resourceUris)
+                        );
+                    }
+                } else if (tc.status === ToolCallStatus.Streaming && !isOtherClientToolCall) {
+                    parts.push(
+                        toolCallStateToStreamingInvocation(tc, undefined, sessionResource, connectionAuthority, mcpServerAuthority)
+                    );
+                } else if (tc.status === ToolCallStatus.Running || tc.status === ToolCallStatus.AuthRequired || tc.status === ToolCallStatus.Streaming || tc.status === ToolCallStatus.PendingConfirmation) {
+                    parts.push(toolCallStateToInvocation(
+                        tc,
+                        undefined,
+                        sessionResource,
+                        connectionAuthority,
+                        mcpServerAuthority,
+                        toolInvocationOptions,
+                        resourceUris
+                    ));
+                }
+                break;
+            }
+        case ResponsePartKind.SystemNotification:
+            {
+                const progress = systemNotificationToChatPart(rp.content, connectionAuthority, rp._meta);
+                if (progress) {
+                    parts.push(progress);
+                }
+            }
+            break;
+        }
+    }
+    return parts;
+}
+function getTerminalInput(tc) {
+    const toolInput = tc.status === ToolCallStatus.Streaming ? undefined : getInlineToolInput(tc.toolInput);
+    if (toolInput) {
+        try {
+            return JSON.parse(toolInput).command || toolInput;
+        } catch {
+            return toolInput;
+        }
+    }
+    return undefined;
+}
+function getTerminalOutput(tc) {
+    if (tc.status !== ToolCallStatus.Completed && tc.status !== ToolCallStatus.Running) {
+        return undefined;
+    }
+    const terminalContent = getTerminalContent(tc.content);
+    const terminalResult = getTerminalCommandResult(tc);
+    const fallbackText = tc.content?.find(isToolResultTextContent)?.text;
+    let text = terminalResult?.truncated === true && fallbackText !== undefined ? stripLegacyTerminalExitMarkers(fallbackText) : terminalResult?.preview;
+    const hasRetainedNonPtySnapshot = terminalContent?.isPty === false && text !== undefined;
+    if (text === undefined && terminalContent?.isPty !== false) {
+        text = fallbackText === undefined ? undefined : stripLegacyTerminalExitMarkers(fallbackText);
+    }
+    if (text === undefined || (!text && !hasRetainedNonPtySnapshot && terminalResult?.truncated !== true)) {
+        return undefined;
+    }
+    return {
+        text: text.replace(/\r?\n/g, "\r\n"),
+        ...(terminalResult?.truncated !== undefined ? {
+            truncated: terminalResult.truncated
+        } : {})
+    };
+}
+function stripLegacyTerminalExitMarkers(text) {
+    return text.replace(/<shellId:[^>\r\n]*completed with exit code -?\d+>\s*$/i, "");
+}
+function isToolResultTextContent(content) {
+    return content.type === ToolResultContentType.Text;
+}
+function getTerminalCommandState(tc, fallbackSuccess) {
+    const terminalResult = tc.status === ToolCallStatus.Completed || tc.status === ToolCallStatus.Running ? getTerminalCommandResult(tc) : undefined;
+    if (terminalResult?.exitCode !== undefined) {
+        return {
+            exitCode: terminalResult.exitCode
+        };
+    }
+    if ((tc.status === ToolCallStatus.Completed || tc.status === ToolCallStatus.Running) && getTerminalContent(tc.content)?.isPty === false) {
+        return fallbackSuccess === false ? {
+            exitCode: 1
+        } : undefined;
+    }
+    return fallbackSuccess === undefined ? undefined : {
+        exitCode: fallbackSuccess ? 0 : 1
+    };
+}
+function isToolResultTerminalContent(content) {
+    return content.type === ToolResultContentType.Terminal;
+}
+function getTerminalCommandResult(tc) {
+    const result = tc.content?.find(isToolResultTerminalContent)?.result;
+    if (result) {
+        return result;
+    }
+    return tc.content?.find(c => c.type === "terminalComplete");
+}
+function getTerminalLanguage(tc) {
+    return tc.toolName === "powershell" ? "powershell" : "shellscript";
+}
+function isTerminalToolCall(tc, existingKind) {
+    if (existingKind === "terminal") {
+        return true;
+    }
+    if (getToolKind(tc) === "terminal" && getTerminalInput(tc) !== undefined) {
+        return true;
+    }
+    if (tc.status === ToolCallStatus.Running || tc.status === ToolCallStatus.Completed) {
+        return !!getTerminalContentUri(tc.content);
+    }
+    return false;
+}
+function buildTerminalToolSpecificData(tc, sessionResource, existing) {
+    const terminalContent = (tc.status === ToolCallStatus.Running || tc.status === ToolCallStatus.Completed) ? getTerminalContent(tc.content) : undefined;
+    const terminalContentUri = terminalContent?.resource;
+    const nextCommand = getTerminalInput(tc);
+    const commandLine = nextCommand ? {
+        ...existing?.commandLine,
+        original: nextCommand
+    } : existing?.commandLine ?? {
+        original: ""
+    };
+    const nextOutput = getTerminalOutput(tc);
+    return {
+        ...existing,
+        kind: "terminal",
+        commandLine,
+        editable: false,
+        intention: tc.intention ?? existing?.intention,
+        language: existing?.language ?? getTerminalLanguage(tc),
+        autoApproveRuleResolvable: readToolCallMeta(tc).autoApproveRuleResolvable ?? existing?.autoApproveRuleResolvable,
+        terminalToolSessionId: terminalContentUri ? makeAhpTerminalToolSessionId(terminalContentUri, sessionResource) : existing?.terminalToolSessionId,
+        terminalCommandUri: terminalContentUri ? ( URI.parse(terminalContentUri)) : existing?.terminalCommandUri,
+        isPty: terminalContent?.isPty ?? existing?.isPty,
+        terminalCommandOutput: nextOutput ?? existing?.terminalCommandOutput
+    };
+}
+function getToolInputOutputDetails(tc, isError, errorString, includeMcpOutput, connectionAuthority) {
+    const toolInput = tc.status === ToolCallStatus.Streaming ? undefined : getInlineToolInput(tc.toolInput);
+    if (!toolInput) {
+        return undefined;
+    }
+    const output = [];
+    if (tc.status === ToolCallStatus.Completed || tc.status === ToolCallStatus.Running) {
+        for (const block of tc.content ?? []) {
+            switch (block.type) {
+            case ToolResultContentType.Text:
+                output.push({
+                    type: "embed",
+                    value: block.text,
+                    isText: true,
+                    mimeType: block.text.trimStart().startsWith("{") ? "application/json" : Mimes.text
+                });
+                break;
+            case ToolResultContentType.EmbeddedResource:
+                output.push({
+                    type: "embed",
+                    value: block.data,
+                    mimeType: block.contentType
+                });
+                break;
+            case ToolResultContentType.Resource:
+                output.push({
+                    type: "ref",
+                    uri: wrapResourceUri(block.uri, connectionAuthority),
+                    mimeType: block.contentType
+                });
+                break;
+            }
+        }
+    }
+    if (output.length === 0 && errorString) {
+        output.push({
+            type: "embed",
+            value: errorString,
+            isText: true,
+            mimeType: "text/plain"
+        });
+    }
+    return {
+        input: toolInput,
+        inputLanguage: "json",
+        output,
+        isError,
+        mcpOutput: includeMcpOutput ? toMcpCallToolResult(tc, isError, connectionAuthority) : undefined
+    };
+}
+function toMcpCallToolResult(tc, isError, connectionAuthority) {
+    if (tc.status !== ToolCallStatus.Completed && tc.status !== ToolCallStatus.Running) {
+        return undefined;
+    }
+    const content = [];
+    for (const block of tc.content ?? []) {
+        const mcpBlock = toMcpContentBlock(block, connectionAuthority);
+        if (mcpBlock) {
+            content.push(mcpBlock);
+        }
+    }
+    if (content.length === 0 && !isError) {
+        return undefined;
+    }
+    return {
+        content,
+        isError: isError || undefined
+    };
+}
+function toMcpContentBlock(block, connectionAuthority) {
+    switch (block.type) {
+    case ToolResultContentType.Text:
+        return {
+            type: "text",
+            text: block.text
+        };
+    case ToolResultContentType.EmbeddedResource:
+        {
+            if (block.contentType.startsWith("image/")) {
+                return {
+                    type: "image",
+                    data: block.data,
+                    mimeType: block.contentType
+                };
+            }
+            if (block.contentType.startsWith("audio/")) {
+                return {
+                    type: "audio",
+                    data: block.data,
+                    mimeType: block.contentType
+                };
+            }
+            return {
+                type: "resource",
+                resource: {
+                    uri: `data:${block.contentType};base64,${block.data}`,
+                    mimeType: block.contentType,
+                    blob: block.data
+                }
+            };
+        }
+    case ToolResultContentType.Resource:
+        {
+            const wrapped = wrapResourceUri(block.uri, connectionAuthority);
+            return {
+                type: "resource_link",
+                name: basename(wrapped) || ( wrapped.toString()),
+                uri: ( wrapped.toString()),
+                mimeType: block.contentType
+            };
+        }
+    default:
+        return undefined;
+    }
+}
+function wrapResourceUri(uri, connectionAuthority) {
+    return toAgentHostUri(( URI.parse(uri)), connectionAuthority);
+}
+function getToolErrorString(tc) {
+    if (tc.status === ToolCallStatus.Completed) {
+        return tc.error?.message;
+    }
+    if (tc.status === ToolCallStatus.Cancelled) {
+        return typeof tc.reasonMessage === "string" ? tc.reasonMessage : tc.reasonMessage?.markdown;
+    }
+    return undefined;
+}
+function buildSessionCreatedToolData(tc) {
+    if (tc.status !== ToolCallStatus.Completed || !tc.success) {
+        return undefined;
+    }
+    const isSend = isSendMessageTool(tc.toolName);
+    if (!isCreateSessionTool(tc.toolName) && !isCreateChatTool(tc.toolName) && !isSend) {
+        return undefined;
+    }
+    const output = getToolOutputText(tc);
+    const match = output?.match(/agent-host-session:\/\/[^\s)<>;"']+/);
+    const openLink = match?.[0];
+    const backend = openLink ? parseOpenSessionLinkUri(openLink) : undefined;
+    if (!openLink || !backend) {
+        return undefined;
+    }
+    const fullTitle = createSessionTitleFromArgs(getInlineToolInput(tc.toolInput)) ?? (backend.path.replace(/^\//, "") || ( backend.toString()));
+    const label = fullTitle.length > 60 ? `${fullTitle.slice(0, 57)}…` : fullTitle;
+    const isChat = isCreateChatTool(tc.toolName) || ((isCreateSessionTool(tc.toolName) || isSend) && !!parseOpenSessionLinkChatId(openLink));
+    return {
+        kind: "sessionCreated",
+        openLink,
+        label,
+        fullTitle,
+        ...(isChat ? {
+            isChat: true
+        } : {})
+    };
+}
+function buildGeneratedImageToolData(tc) {
+    if (tc.status !== ToolCallStatus.Completed || !tc.success || tc.toolName !== imageGenerationToolName) {
+        return undefined;
+    }
+    const hasImage = tc.content?.some(
+        block => block.type === ToolResultContentType.EmbeddedResource && block.contentType.startsWith("image/") && block.data.length > 0
+    );
+    return hasImage ? {
+        kind: "generatedImage"
+    } : undefined;
+}
+function buildAutomationConfiguredToolData(tc) {
+    if (tc.status !== ToolCallStatus.Completed || !tc.success || tc.toolName !== ConfigureAutomationToolReferenceName) {
+        return undefined;
+    }
+    const output = getToolOutputText(tc);
+    if (!output) {
+        return undefined;
+    }
+    try {
+        const parsed = JSON.parse(output);
+        const operation = parsed.status === "created" || parsed.status === "updated" ? parsed.status : undefined;
+        if (!operation || typeof parsed.automation?.id !== "string" || typeof parsed.automation.name !== "string") {
+            return undefined;
+        }
+        return {
+            kind: "automationConfigured",
+            automationId: parsed.automation.id,
+            automationName: parsed.automation.name,
+            operation
+        };
+    } catch {
+        return undefined;
+    }
+}
+function createSessionTitleFromArgs(toolInput) {
+    if (!toolInput) {
+        return undefined;
+    }
+    try {
+        const args = JSON.parse(toolInput);
+        const text = typeof args.prompt === "string" ? args.prompt : (typeof args.message === "string" ? args.message : undefined);
+        if (text === undefined) {
+            return undefined;
+        }
+        const firstLine = text.trim().split("\n")[0].trim();
+        if (!firstLine) {
+            return undefined;
+        }
+        return firstLine;
+    } catch {
+        return undefined;
+    }
+}
+function completedToolCallConfirmedReason(tc) {
+    if (tc.status === ToolCallStatus.Completed) {
+        return {
+            type: ToolConfirmKind.ConfirmationNotNeeded
+        };
+    }
+    return {
+        type: tc.reason === ToolCallCancellationReason.Skipped ? ToolConfirmKind.Skipped : ToolConfirmKind.Denied
+    };
+}
+function completedToolCallToSerialized(
+    tc,
+    subAgentInvocationId,
+    sessionResource,
+    connectionAuthority,
+    resourceUris = createAgentHostResourceUriMapper(connectionAuthority)
+) {
+    const isTerminal = isTerminalToolCall(tc);
+    const isSuccess = tc.status === ToolCallStatus.Completed && tc.success;
+    let invocationMsg = stringOrMarkdownToString(tc.invocationMessage, connectionAuthority) ?? tc.displayName;
+    const subagentContent = tc.status === ToolCallStatus.Completed ? getToolSubagentContent(tc) : undefined;
+    const isSubagent = subagentContent || isSubagentTool(tc);
+    if (isSubagent && tc.status === ToolCallStatus.Completed) {
+        const resultText = getToolOutputText(tc);
+        const pastTenseMsg = isSuccess ? stringOrMarkdownToString(tc.pastTenseMessage, connectionAuthority) ?? invocationMsg : invocationMsg;
+        return {
+            kind: "toolInvocationSerialized",
+            toolCallId: tc.toolCallId,
+            toolId: tc.toolName,
+            source: ToolDataSource.Internal,
+            invocationMessage: invocationMsg,
+            originMessage: undefined,
+            pastTenseMessage: pastTenseMsg,
+            isConfirmed: completedToolCallConfirmedReason(tc),
+            isComplete: true,
+            presentation: undefined,
+            subAgentInvocationId: subAgentInvocationId,
+            toolSpecificData: {
+                kind: "subagent",
+                hasStarted: false,
+                description: getSubagentTaskDescription(tc) ?? tc.displayName,
+                ...(subagentContent?.title ? {
+                    agentDisplayName: subagentContent.title
+                } : {}),
+                agentName: subagentContent?.agentName ?? getSubagentAgentName(tc),
+                result: resultText,
+                chatResource: getSubagentChatResource(tc, subagentContent, sessionResource),
+                isChatAvailable: false
+            }
+        };
+    }
+    let toolSpecificData;
+    if (isTerminal) {
+        toolSpecificData = {
+            ...buildTerminalToolSpecificData(tc, sessionResource),
+            terminalCommandState: getTerminalCommandState(tc, isSuccess)
+        };
+    } else if (getToolKind(tc) === "search") {
+        toolSpecificData = {
+            kind: "search"
+        };
+    } else {
+        toolSpecificData = buildSessionCreatedToolData(tc) ?? buildGeneratedImageToolData(tc) ?? buildAutomationConfiguredToolData(tc);
+        if (!toolSpecificData) {
+            toolSpecificData = buildMcpAppToolInputData(tc, connectionAuthority);
+        }
+    }
+    let pastTenseMsg = isSuccess ? stringOrMarkdownToString(tc.pastTenseMessage, connectionAuthority) ?? invocationMsg : invocationMsg;
+    if (isAddCommentTool(tc.toolName)) {
+        const ref = addCommentReference(tc, resourceUris);
+        if (ref) {
+            invocationMsg = ref;
+            pastTenseMsg = ref;
+        }
+    }
+    const resultDetails = (!toolSpecificData || toolSpecificData.kind === "generatedImage" || toolSpecificData.kind === "input" && toolSpecificData.mcpAppData) && (tc.status !== ToolCallStatus.Completed || getToolFileEdits(tc).length === 0) ? getToolInputOutputDetails(
+        tc,
+        !isSuccess,
+        getToolErrorString(tc),
+        !!(toolSpecificData?.kind === "input" && toolSpecificData.mcpAppData),
+        connectionAuthority
+    ) : undefined;
+    return {
+        kind: "toolInvocationSerialized",
+        toolCallId: tc.toolCallId,
+        toolId: tc.toolName,
+        source: ToolDataSource.Internal,
+        invocationMessage: invocationMsg,
+        originMessage: undefined,
+        pastTenseMessage: isTerminal ? undefined : pastTenseMsg,
+        isConfirmed: completedToolCallConfirmedReason(tc),
+        isComplete: true,
+        presentation: shouldHideAutomaticTitleRename(tc) ? ToolInvocationPresentation.Hidden : shouldHideCompletedAgentHostAskUserTool(tc) ? ToolInvocationPresentation.HiddenAfterComplete : undefined,
+        subAgentInvocationId: subAgentInvocationId,
+        toolSpecificData,
+        resultDetails
+    };
+}
+function completedToolCallToEditParts(tc, connectionAuthority) {
+    if (tc.status !== ToolCallStatus.Completed) {
+        return [];
+    }
+    const fileEdits = getToolFileEdits(tc);
+    if (fileEdits.length === 0) {
+        return [];
+    }
+    const parts = [];
+    for (const edit of fileEdits) {
+        const part = fileEditToExternalEdit(edit, tc.toolCallId, connectionAuthority);
+        if (part) {
+            parts.push(part);
+        }
+    }
+    return parts;
+}
+function fileEditToExternalEdit(edit, undoStopId, connectionAuthority) {
+    const normalized = normalizeFileEdit(edit);
+    if (!normalized) {
+        return undefined;
+    }
+    const diff = edit.diff && (edit.diff.added !== undefined || edit.diff.removed !== undefined) ? {
+        added: edit.diff.added ?? 0,
+        removed: edit.diff.removed ?? 0
+    } : undefined;
+    return {
+        kind: "externalEdit",
+        uri: toAgentHostUri(normalized.resource, connectionAuthority),
+        editKind: normalized.kind,
+        originalUri: normalized.kind === FileEditKind.Rename && normalized.beforeUri ? toAgentHostUri(normalized.beforeUri, connectionAuthority) : undefined,
+        beforeContentUri: normalized.beforeContentUri ? toAgentHostContentUri(normalized.beforeContentUri, connectionAuthority) : undefined,
+        afterContentUri: normalized.afterContentUri ? toAgentHostContentUri(normalized.afterContentUri, connectionAuthority) : undefined,
+        diff,
+        undoStopId
+    };
+}
+const EXTERNAL_LINK_SCHEMES = ( new Set([
+    "http",
+    "https",
+    "mailto",
+    "ws",
+    "wss",
+    "ftp",
+    "ftps",
+    "data",
+    "blob",
+    "javascript",
+    "command",
+    "vscode",
+    "vscode-insiders",
+    Schemas.vscodeBrowser,
+    "copilot-skill",
+    product.urlProtocol,
+    AGENT_HOST_SCHEME,
+    AGENT_HOST_SESSION_LINK_SCHEME
+]));
+function rewriteMarkdownLinks(markdown, connectionAuthority) {
+    return rewriteMarkdownLinks$1(markdown, {
+        rewriteLink: token => rewriteLinkTokenRaw(token, connectionAuthority)
+    });
+}
+function rewriteLinkTokenRaw(token, connectionAuthority) {
+    let parsed;
+    try {
+        parsed = ( URI.parse(token.href, true));
+    } catch {
+        return undefined;
+    }
+    const scheme = parsed.scheme.toLowerCase();
+    if (!scheme || ( EXTERNAL_LINK_SCHEMES.has(scheme))) {
+        return undefined;
+    }
+    let agentHostUri = toAgentHostUri(parsed, connectionAuthority);
+    const isSkill = isSkillFileUri(parsed);
+    if (isSkill && !agentHostUri.query.includes("vscodeLinkType=")) {
+        const existing = agentHostUri.query;
+        agentHostUri = agentHostUri.with({
+            query: existing ? `${existing}&vscodeLinkType=skill` : "vscodeLinkType=skill"
+        });
+    }
+    const prefix = token.type === "image" ? "![" : "[";
+    const text = isSkill || token.type === "image" ? escapeMarkdownLinkLabel(token.text ?? "") : "";
+    return `${prefix}${text}](${( agentHostUri.toString())})`;
+}
+function isSkillFileUri(uri) {
+    const name = basename(uri);
+    return name.toLowerCase() === "skill.md";
+}
+function rawMarkdownToString(content, connectionAuthority) {
+    const rewritten = connectionAuthority ? rewriteMarkdownLinks(content, connectionAuthority) : content;
+    return ( new MarkdownString(rewritten));
+}
+function parseAbsoluteFileLinkTarget(href) {
+    const fragmentIndex = href.indexOf("#");
+    const rawPath = fragmentIndex >= 0 ? href.substring(0, fragmentIndex) : href;
+    if (rawPath.includes("?")) {
+        return undefined;
+    }
+    const existingFragment = fragmentIndex >= 0 ? href.substring(fragmentIndex + 1) : "";
+    const parsedPath = existingFragment ? {
+        path: rawPath
+    } : parseFileLocation(rawPath);
+    let decodedPath;
+    try {
+        decodedPath = decodeURIComponent(parsedPath.path);
+    } catch {
+        return undefined;
+    }
+    const absolutePath = decodedPath;
+    const isWindowsPath = win32.isAbsolute(absolutePath);
+    if (!posix.isAbsolute(absolutePath) && !isWindowsPath) {
+        return undefined;
+    }
+    const selectionFragment = formatLocationFragment(parsedPath);
+    const normalizedPath = isWindowsPath ? absolutePath.replaceAll("\\", "/") : absolutePath;
+    return URI.file(normalizedPath).with({
+        fragment: existingFragment || selectionFragment
+    });
+}
+function parseFileLocation(path) {
+    const match = /^(?<path>.+?):(?<line>[1-9]\d*)(?::(?<column>[1-9]\d*))?$/.exec(path);
+    if (!match?.groups) {
+        return {
+            path
+        };
+    }
+    const line = Number(match.groups.line);
+    const column = match.groups.column ? Number(match.groups.column) : undefined;
+    if (!Number.isSafeInteger(line) || column !== undefined && !Number.isSafeInteger(column)) {
+        return {
+            path
+        };
+    }
+    return {
+        path: match.groups.path,
+        line,
+        column
+    };
+}
+function formatLocationFragment(location) {
+    if (location.line === undefined) {
+        return "";
+    }
+    return `L${location.line}${location.column !== undefined && location.column !== 1 ? `,${location.column}` : ""}`;
+}
+function normalizeFileUriSelection(uri, href) {
+    if (uri.scheme.toLowerCase() !== Schemas.file || uri.query || uri.fragment) {
+        return uri;
+    }
+    const parsedPath = parseFileLocation(href);
+    if (parsedPath.line === undefined) {
+        return uri;
+    }
+    const fragment = formatLocationFragment(parsedPath);
+    const suffixLength = href.length - parsedPath.path.length;
+    return uri.with({
+        path: uri.path.substring(0, uri.path.length - suffixLength),
+        fragment
+    });
+}
+function rewriteAgentHostLinkTarget(
+    href,
+    connectionAuthority,
+    resourceUris = createAgentHostResourceUriMapper(connectionAuthority)
+) {
+    let parsed = parseAbsoluteFileLinkTarget(href);
+    if (!parsed) {
+        try {
+            parsed = ( URI.parse(href, true));
+        } catch {
+            return href;
+        }
+        const scheme = parsed.scheme.toLowerCase();
+        if (!scheme || ( EXTERNAL_LINK_SCHEMES.has(scheme))) {
+            return href;
+        }
+        parsed = normalizeFileUriSelection(parsed.with({
+            scheme
+        }), href);
+        if (!parsed.path.startsWith("/")) {
+            return href;
+        }
+    }
+    let agentHostUri;
+    try {
+        agentHostUri = resourceUris.fromAgentHost(parsed);
+        if (parsed.scheme !== Schemas.file && isEqual(agentHostUri, parsed)) {
+            agentHostUri = toAgentHostUri(parsed, connectionAuthority);
+        }
+    } catch {
+        return href;
+    }
+    if (isSkillFileUri(parsed) && !agentHostUri.query.includes("vscodeLinkType=")) {
+        const existing = agentHostUri.query;
+        agentHostUri = agentHostUri.with({
+            query: existing ? `${existing}&vscodeLinkType=skill` : "vscodeLinkType=skill"
+        });
+    }
+    return ( agentHostUri.toString());
+}
+function stringOrMarkdownToString(value, connectionAuthority) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (typeof value === "string") {
+        return value;
+    }
+    return rawMarkdownToString(value.markdown, connectionAuthority);
+}
+const ADD_COMMENT_PREVIEW_LENGTH = 40;
+function addCommentPreview(text) {
+    const singleLine = text.replace(/\s+/g, " ").trim();
+    return singleLine.length > ADD_COMMENT_PREVIEW_LENGTH ? `${singleLine.slice(0, ADD_COMMENT_PREVIEW_LENGTH)}…` : singleLine;
+}
+function isPositiveInteger(value) {
+    return typeof value === "number" && Number.isInteger(value) && value >= 1;
+}
+function isOneBasedRange(value) {
+    const range = value;
+    return !!range && typeof range === "object" && isPositiveInteger(range.startLineNumber) && isPositiveInteger(range.startColumn) && isPositiveInteger(range.endLineNumber) && isPositiveInteger(range.endColumn);
+}
+function addCommentReference(tc, resourceUris) {
+    if (tc.status === ToolCallStatus.Streaming || !tc.toolInput) {
+        return undefined;
+    }
+    const toolInput = getInlineToolInput(tc.toolInput);
+    if (!toolInput) {
+        return undefined;
+    }
+    let args;
+    try {
+        args = JSON.parse(toolInput);
+    } catch {
+        return undefined;
+    }
+    if (typeof args.resourceUri !== "string" || typeof args.text !== "string" || !isOneBasedRange(args.range)) {
+        return undefined;
+    }
+    const preview = escapeIcons(escapeMarkdownLinkLabel(addCommentPreview(args.text)));
+    const resource = resourceUris.fromAgentHost(( URI.parse(args.resourceUri)));
+    const commandArgs = encodeURIComponent(JSON.stringify([( resource.toString()), args.range]));
+    const link = `command:${AgentFeedbackReviewCommandId.RevealAt}?${commandArgs}`;
+    return ( new MarkdownString(`[addComment "${preview}"](${link})`, {
+        isTrusted: {
+            enabledCommands: [AgentFeedbackReviewCommandId.RevealAt]
+        },
+        supportThemeIcons: true
+    }));
+}
+function toolCallStateToInvocation(
+    tc,
+    subAgentInvocationId,
+    sessionResource,
+    connectionAuthority,
+    mcpServerAuthority = sessionResource.authority,
+    options,
+    resourceUris = createAgentHostResourceUriMapper(connectionAuthority)
+) {
+    const toolData = {
+        id: tc.toolName,
+        source: ToolDataSource.Internal,
+        displayName: tc.displayName,
+        modelDescription: tc.toolName
+    };
+    const subagentData = getSubagentToolSpecificData(tc, sessionResource);
+    if (tc.contributor?.kind === ToolCallContributorKind.Client && options && tc.contributor.clientId !== options.currentClientId) {
+        const invocation = ( new ChatToolInvocation(undefined, toolData, tc.toolCallId, subAgentInvocationId, undefined));
+        invocation.invocationMessage = ( localize(8121, "Running {0} on another client...", tc.displayName));
+        invocation.toolSpecificData = subagentData;
+        invocation.otherClientToolCall = {
+            cancel: () => options.cancelOtherClientToolCall(tc)
+        };
+        return invocation;
+    }
+    if (tc.status === ToolCallStatus.PendingConfirmation) {
+        const confirmationMessages = toolCallConfirmationMessages(tc, connectionAuthority);
+        let toolSpecificData;
+        const pendingEdits = tc.edits?.items;
+        if (isViewUnreviewedCommentsTool(tc.toolName)) {
+            toolSpecificData = {
+                kind: "agentFeedbackReviewConfirmation",
+                options: [( localize(8122, "Reveal Selected"))]
+            };
+        } else if (pendingEdits?.length) {
+            const wrap = uri => connectionAuthority ? toAgentHostUri(uri, connectionAuthority) : uri;
+            const wrapContent = uri => connectionAuthority ? toAgentHostContentUri(uri, connectionAuthority) : uri;
+            const mapped = mapFileEdits(pendingEdits, tc.toolCallId);
+            toolSpecificData = {
+                kind: "modifiedFilesConfirmation",
+                options: ["Allow"],
+                modifiedFiles: mapped.map(edit => {
+                    const resource = wrap(edit.resource);
+                    const originalResource = edit.originalResource ? wrap(edit.originalResource) : undefined;
+                    const modifiedContent = edit.afterContentUri ? wrapContent(edit.afterContentUri) : undefined;
+                    const originalContent = edit.beforeContentUri ? wrapContent(edit.beforeContentUri) : undefined;
+                    return {
+                        uri: resource,
+                        editKind: edit.kind,
+                        originalUri: originalResource,
+                        modifiedContentUri: modifiedContent,
+                        originalContentUri: originalContent,
+                        insertions: edit.diff?.added,
+                        deletions: edit.diff?.removed,
+                        title: basename(edit.resource),
+                        description: edit.resource.path
+                    };
+                })
+            };
+        } else if (getToolKind(tc) === "terminal" && getInlineToolInput(tc.toolInput)) {
+            toolSpecificData = buildTerminalToolSpecificData(tc, sessionResource);
+        } else if (!isSetWorkspaceTool(tc)) {
+            const toolInput = getInlineToolInput(tc.toolInput);
+            if (toolInput) {
+                let rawInput;
+                try {
+                    rawInput = JSON.parse(toolInput);
+                } catch {
+                    rawInput = {
+                        input: toolInput
+                    };
+                }
+                toolSpecificData = {
+                    kind: "input",
+                    rawInput,
+                    editable: false
+                };
+            }
+        }
+        return ( new ChatToolInvocation({
+            invocationMessage: stringOrMarkdownToString(tc.invocationMessage, connectionAuthority),
+            confirmationMessages,
+            presentation: ToolInvocationPresentation.HiddenAfterComplete,
+            toolSpecificData
+        }, toolData, tc.toolCallId, subAgentInvocationId, undefined));
+    }
+    const invocation = ( new ChatToolInvocation(undefined, toolData, tc.toolCallId, subAgentInvocationId, undefined));
+    invocation.invocationMessage = stringOrMarkdownToString(tc.invocationMessage, connectionAuthority) ?? tc.displayName;
+    if (isAgentHostAskUserTool(tc.toolName)) {
+        invocation.invocationMessage = ( localize(8123, "Waiting for answer..."));
+        invocation.presentation = ToolInvocationPresentation.HiddenAfterComplete;
+    } else if (shouldHideAutomaticTitleRename(tc)) {
+        invocation.presentation = ToolInvocationPresentation.Hidden;
+    }
+    if (tc.status === ToolCallStatus.AuthRequired) {
+        invocation.setAuthenticationRequired(toolCallAuthenticationServer(tc, mcpServerAuthority));
+    }
+    applyToolCallProgress(invocation, tc);
+    if (isAddCommentTool(tc.toolName)) {
+        invocation.invocationMessage = addCommentReference(tc, resourceUris) ?? invocation.invocationMessage;
+    }
+    if (isTerminalToolCall(tc)) {
+        invocation.toolSpecificData = buildTerminalToolSpecificData(tc, sessionResource);
+    } else if (subagentData) {
+        invocation.toolSpecificData = subagentData;
+    } else if (getToolKind(tc) === "search") {
+        invocation.toolSpecificData = {
+            kind: "search"
+        };
+    } else if (tc.status !== ToolCallStatus.Streaming) {
+        invocation.toolSpecificData = buildMcpAppToolInputData(tc, connectionAuthority);
+    }
+    return invocation;
+}
+function toolCallConfirmationMessages(tc, connectionAuthority) {
+    const riskAssessment = tc.riskAssessment;
+    let approvalReason;
+    if (riskAssessment?.status === ToolCallRiskAssessmentStatus.Loading) {
+        approvalReason = {
+            status: "loading"
+        };
+    } else if (riskAssessment?.status === ToolCallRiskAssessmentStatus.Complete) {
+        approvalReason = {
+            status: "complete",
+            explanation: stringOrMarkdownToString(riskAssessment.reason, connectionAuthority),
+            safety: riskAssessment.safety
+        };
+    }
+    return {
+        title: isViewUnreviewedCommentsTool(tc.toolName) ? ( localize(8124, "Reveal unreviewed comments?")) : stringOrMarkdownToString(tc.confirmationTitle, connectionAuthority) ?? tc.displayName,
+        message: isViewUnreviewedCommentsTool(tc.toolName) ? ( localize(
+            8125,
+            "Choose which comments to reveal to the agent. Unchecked comments stay hidden."
+        )) : stringOrMarkdownToString(tc.invocationMessage, connectionAuthority),
+        approvalReason,
+        ...(tc.options ? {
+            customOptions: tc.options
+        } : {})
+    };
+}
+function toolCallAuthenticationServer(tc, sessionAuthority) {
+    const metadata = readToolCallMeta(tc);
+    return {
+        id: `${sessionAuthority}/${tc.contributor.customizationId}`,
+        name: tc.auth.resource.resource_name ?? metadata.mcpServerName ?? tc.displayName,
+        resource: tc.auth.resource.resource,
+        oauthClient: tc.auth.oauthClient,
+        authorizationServers: tc.auth.resource.authorization_servers,
+        supportedScopes: tc.auth.resource.scopes_supported,
+        requiredScopes: tc.auth.requiredScopes,
+        reason: tc.auth.reason
+    };
+}
+function toolCallStateToStreamingInvocation(
+    tc,
+    subAgentInvocationId,
+    sessionResource,
+    connectionAuthority,
+    mcpServerAuthority
+) {
+    const invocation = ChatToolInvocation.createStreaming({
+        toolCallId: tc.toolCallId,
+        toolId: tc.toolName,
+        toolData: {
+            id: tc.toolName,
+            source: ToolDataSource.Internal,
+            displayName: tc.displayName,
+            modelDescription: tc.toolName
+        },
+        subagentInvocationId: subAgentInvocationId
+    });
+    updateStreamingToolInvocation(invocation, tc, connectionAuthority ?? "");
+    if (isAgentHostAskUserTool(tc.toolName)) {
+        invocation.invocationMessage = ( localize(8126, "Asking a question..."));
+        invocation.presentation = ToolInvocationPresentation.HiddenAfterComplete;
+    } else if (isRenameChatTool(tc)) {
+        invocation.presentation = ToolInvocationPresentation.Hidden;
+    }
+    if (getToolKind(tc) === "search") {
+        invocation.toolSpecificData = {
+            kind: "search"
+        };
+    } else if (sessionResource && isSubagentTool(tc)) {
+        invocation.toolSpecificData = toolCallStateToInvocation(
+            tc,
+            subAgentInvocationId,
+            sessionResource,
+            connectionAuthority ?? "",
+            mcpServerAuthority
+        ).toolSpecificData;
+    }
+    return invocation;
+}
+function getStreamingToolInputForDisplay(tc) {
+    if (tc.status !== ToolCallStatus.Streaming || !tc.partialInput) {
+        return undefined;
+    }
+    return parsePartialToolInputForDisplay(tc.partialInput) ?? tc.partialInput;
+}
+function updateStreamingToolInvocation(existing, tc, connectionAuthority) {
+    if (tc.status !== ToolCallStatus.Streaming) {
+        return undefined;
+    }
+    if (getToolKind(tc) === "read") {
+        existing.updatePartialInput(undefined);
+        existing.updateStreamingMessage(( localize(8127, "Reading file")));
+        return undefined;
+    }
+    const partialInput = getStreamingToolInputForDisplay(tc);
+    if (partialInput !== undefined) {
+        existing.updatePartialInput(partialInput);
+    }
+    const invocationMessage = stringOrMarkdownToString(tc.invocationMessage, connectionAuthority);
+    if (invocationMessage) {
+        existing.updateStreamingMessage(invocationMessage);
+    }
+    return partialInput;
+}
+function toolCallStateToPreparedInvocation(
+    tc,
+    sessionResource,
+    connectionAuthority,
+    mcpServerAuthority = sessionResource.authority,
+    options,
+    resourceUris = createAgentHostResourceUriMapper(connectionAuthority)
+) {
+    const built = toolCallStateToInvocation(
+        tc,
+        undefined,
+        sessionResource,
+        connectionAuthority,
+        mcpServerAuthority,
+        options,
+        resourceUris
+    );
+    return {
+        invocationMessage: built.invocationMessage,
+        pastTenseMessage: built.pastTenseMessage,
+        confirmationMessages: built.confirmationMessages,
+        presentation: built.presentation,
+        toolSpecificData: built.toolSpecificData
+    };
+}
+function updateRunningToolSpecificData(
+    existing,
+    tc,
+    sessionResource,
+    connectionAuthority,
+    resourceUris = createAgentHostResourceUriMapper(connectionAuthority)
+) {
+    if (tc.status !== ToolCallStatus.Running) {
+        return;
+    }
+    existing.invocationMessage = stringOrMarkdownToString(tc.invocationMessage, connectionAuthority) ?? existing.invocationMessage;
+    if (isAgentHostAskUserTool(tc.toolName)) {
+        existing.invocationMessage = ( localize(8123, "Waiting for answer..."));
+        existing.presentation = ToolInvocationPresentation.HiddenAfterComplete;
+    }
+    if (isAddCommentTool(tc.toolName)) {
+        existing.invocationMessage = addCommentReference(tc, resourceUris) ?? existing.invocationMessage;
+    }
+    applyToolCallProgress(existing, tc);
+    const subagentContent = getToolSubagentContent(tc);
+    if (subagentContent) {
+        existing.toolSpecificData = {
+            kind: "subagent",
+            hasStarted: existing.toolSpecificData?.kind === "subagent" ? existing.toolSpecificData.hasStarted : false,
+            isActive: existing.toolSpecificData?.kind === "subagent" ? existing.toolSpecificData.isActive : undefined,
+            isChatAvailable: existing.toolSpecificData?.kind === "subagent" ? existing.toolSpecificData.isChatAvailable : false,
+            description: getSubagentTaskDescription(tc),
+            agentDisplayName: subagentContent.title,
+            agentName: subagentContent.agentName,
+            credits: existing.toolSpecificData?.kind === "subagent" ? existing.toolSpecificData.credits : undefined,
+            modelName: existing.toolSpecificData?.kind === "subagent" ? existing.toolSpecificData.modelName : undefined,
+            startedAt: existing.toolSpecificData?.kind === "subagent" ? existing.toolSpecificData.startedAt : undefined,
+            duration: existing.toolSpecificData?.kind === "subagent" ? existing.toolSpecificData.duration : undefined,
+            chatResource: subagentContent.resource
+        };
+        existing.notifyToolSpecificDataChanged();
+        return;
+    }
+    if (existing.toolSpecificData?.kind === "subagent") {
+        const description = getSubagentTaskDescription(tc) ?? existing.toolSpecificData.description;
+        const agentName = getSubagentAgentName(tc) ?? existing.toolSpecificData.agentName;
+        if (description !== existing.toolSpecificData.description || agentName !== existing.toolSpecificData.agentName) {
+            existing.toolSpecificData = {
+                ...existing.toolSpecificData,
+                description,
+                agentName
+            };
+            existing.notifyToolSpecificDataChanged();
+        }
+        return;
+    }
+    const existingInput = existing.toolSpecificData?.kind === "input" ? existing.toolSpecificData : undefined;
+    const nextInput = buildMcpAppToolInputData(tc, connectionAuthority, existingInput?.rawInput);
+    if (nextInput) {
+        if (!existingInput || !isSameMcpAppData(existingInput.mcpAppData, nextInput.mcpAppData)) {
+            existing.toolSpecificData = nextInput;
+            existing.notifyToolSpecificDataChanged();
+        }
+        return;
+    }
+    const existingTerminal = existing.toolSpecificData?.kind === "terminal" ? existing.toolSpecificData : undefined;
+    if (isTerminalToolCall(tc, existing.toolSpecificData?.kind)) {
+        const next = buildTerminalToolSpecificData(tc, sessionResource, existingTerminal);
+        const outputChanged = next.terminalCommandOutput?.text !== existingTerminal?.terminalCommandOutput?.text;
+        const commandChanged = next.commandLine.original !== existingTerminal?.commandLine.original;
+        if (!existingTerminal || outputChanged || commandChanged) {
+            existing.toolSpecificData = next;
+            existing.notifyToolSpecificDataChanged();
+        }
+    }
+}
+function finalizeToolInvocation(
+    invocation,
+    tc,
+    backendSession,
+    connectionAuthority,
+    resourceUris = createAgentHostResourceUriMapper(connectionAuthority)
+) {
+    const isCompleted = tc.status === ToolCallStatus.Completed;
+    const isCancelled = tc.status === ToolCallStatus.Cancelled;
+    const isTerminal = isTerminalToolCall(tc, invocation.toolSpecificData?.kind);
+    if ((isCompleted || isCancelled) && hasKey(tc, {
+        invocationMessage: true
+    })) {
+        invocation.invocationMessage = stringOrMarkdownToString(tc.invocationMessage, connectionAuthority) ?? invocation.invocationMessage;
+    }
+    if (isAddCommentTool(tc.toolName)) {
+        invocation.invocationMessage = addCommentReference(tc, resourceUris) ?? invocation.invocationMessage;
+    }
+    if (isAgentHostAskUserTool(tc.toolName)) {
+        invocation.presentation = ToolInvocationPresentation.HiddenAfterComplete;
+    }
+    if (isCompleted) {
+        const subagentContent = getToolSubagentContent(tc);
+        if (subagentContent) {
+            const resultText = getToolOutputText(tc);
+            invocation.toolSpecificData = {
+                kind: "subagent",
+                hasStarted: invocation.toolSpecificData?.kind === "subagent" ? invocation.toolSpecificData.hasStarted : false,
+                isActive: invocation.toolSpecificData?.kind === "subagent" ? invocation.toolSpecificData.isActive : undefined,
+                isChatAvailable: invocation.toolSpecificData?.kind === "subagent" ? invocation.toolSpecificData.isChatAvailable : false,
+                description: getSubagentTaskDescription(tc),
+                agentDisplayName: subagentContent.title,
+                agentName: subagentContent.agentName,
+                result: resultText,
+                credits: invocation.toolSpecificData?.kind === "subagent" ? invocation.toolSpecificData.credits : undefined,
+                modelName: invocation.toolSpecificData?.kind === "subagent" ? invocation.toolSpecificData.modelName : undefined,
+                startedAt: invocation.toolSpecificData?.kind === "subagent" ? invocation.toolSpecificData.startedAt : undefined,
+                duration: invocation.toolSpecificData?.kind === "subagent" ? invocation.toolSpecificData.duration : undefined,
+                chatResource: getSubagentChatResource(tc, subagentContent, backendSession)
+            };
+        } else if (invocation.toolSpecificData?.kind === "subagent") {
+            invocation.toolSpecificData = {
+                kind: "subagent",
+                hasStarted: invocation.toolSpecificData.hasStarted,
+                isActive: invocation.toolSpecificData.isActive,
+                isChatAvailable: invocation.toolSpecificData.isChatAvailable,
+                description: getSubagentTaskDescription(tc) ?? invocation.toolSpecificData.description,
+                ...(invocation.toolSpecificData.agentDisplayName ? {
+                    agentDisplayName: invocation.toolSpecificData.agentDisplayName
+                } : {}),
+                agentName: getSubagentAgentName(tc) ?? invocation.toolSpecificData.agentName,
+                result: getToolOutputText(tc),
+                credits: invocation.toolSpecificData.credits,
+                modelName: invocation.toolSpecificData.modelName,
+                startedAt: invocation.toolSpecificData.startedAt,
+                duration: invocation.toolSpecificData.duration,
+                chatResource: invocation.toolSpecificData.chatResource ?? getSubagentChatResource(tc, undefined, backendSession)
+            };
+        }
+    }
+    if (isTerminal && (isCompleted || isCancelled)) {
+        const existing = invocation.toolSpecificData?.kind === "terminal" ? invocation.toolSpecificData : undefined;
+        invocation.presentation = undefined;
+        invocation.toolSpecificData = {
+            ...buildTerminalToolSpecificData(tc, backendSession, existing),
+            terminalCommandState: getTerminalCommandState(tc, isCompleted && tc.success)
+        };
+    } else if (isCompleted && tc.pastTenseMessage) {
+        invocation.pastTenseMessage = stringOrMarkdownToString(tc.pastTenseMessage, connectionAuthority);
+    }
+    if (isCompleted && isAddCommentTool(tc.toolName)) {
+        invocation.pastTenseMessage = addCommentReference(tc, resourceUris) ?? invocation.pastTenseMessage;
+    }
+    if (isCompleted) {
+        const resultToolSpecificData = buildSessionCreatedToolData(tc) ?? buildGeneratedImageToolData(tc) ?? buildAutomationConfiguredToolData(tc);
+        if (resultToolSpecificData) {
+            invocation.presentation = undefined;
+            invocation.toolSpecificData = resultToolSpecificData;
+            invocation.notifyToolSpecificDataChanged();
+        }
+    }
+    if (isCompleted) {
+        const mcpAppInput = buildMcpAppToolInputData(
+            tc,
+            connectionAuthority,
+            invocation.toolSpecificData?.kind === "input" ? invocation.toolSpecificData.rawInput : undefined
+        );
+        if (mcpAppInput) {
+            const existingInput = invocation.toolSpecificData?.kind === "input" ? invocation.toolSpecificData : undefined;
+            invocation.toolSpecificData = mcpAppInput;
+            if (!existingInput || !isSameMcpAppData(existingInput.mcpAppData, mcpAppInput.mcpAppData)) {
+                invocation.notifyToolSpecificDataChanged();
+            }
+        }
+    }
+    const isFailure = (isCompleted && !tc.success) || isCancelled;
+    const errorMessage = isCompleted ? tc.error?.message : (isCancelled ? tc.reasonMessage : undefined);
+    const errorString = typeof errorMessage === "string" ? errorMessage : errorMessage?.markdown;
+    const fileEdits = isCompleted ? fileEditsToExternalEdits(tc) : [];
+    if (isAgentHostAskUserTool(tc.toolName)) {
+        invocation.presentation = shouldHideCompletedAgentHostAskUserTool(tc) ? ToolInvocationPresentation.HiddenAfterComplete : undefined;
+    } else if (isAutomaticTitleRename(tc)) {
+        invocation.presentation = shouldHideAutomaticTitleRename(tc) ? ToolInvocationPresentation.Hidden : undefined;
+    }
+    if (fileEdits.length > 0 && !isFailure) {
+        invocation.presentation = ToolInvocationPresentation.Hidden;
+    }
+    const hasMcpAppData = invocation.toolSpecificData?.kind === "input" && !!invocation.toolSpecificData.mcpAppData;
+    const resultDetails = !isTerminal && invocation.toolSpecificData?.kind !== "subagent" && invocation.toolSpecificData?.kind !== "sessionCreated" && getToolKind(tc) !== "search" && fileEdits.length === 0 ? getToolInputOutputDetails(tc, isFailure, errorString, hasMcpAppData, connectionAuthority) : undefined;
+    const result = isFailure || resultDetails ? {
+        content: [],
+        toolResultError: isFailure ? errorString : undefined,
+        toolResultDetails: resultDetails
+    } : undefined;
+    invocation.acceptProgress({
+        message: undefined
+    });
+    const cancelledFromStreaming = isCancelled && invocation.cancelFromStreaming(
+        tc.reason === ToolCallCancellationReason.Skipped ? ToolConfirmKind.Skipped : ToolConfirmKind.Denied,
+        tc.reasonMessage ? stringOrMarkdownToString(tc.reasonMessage, connectionAuthority) : undefined
+    );
+    if (!cancelledFromStreaming) {
+        invocation.didExecuteTool(result);
+    }
+    return fileEdits;
+}
+function fileEditsToExternalEdits(tc) {
+    if (tc.status !== ToolCallStatus.Completed) {
+        return [];
+    }
+    const edits = getToolFileEdits(tc);
+    if (edits.length === 0) {
+        return [];
+    }
+    return mapFileEdits(edits, tc.toolCallId);
+}
+function mapFileEdits(items, undoStopId) {
+    const result = [];
+    for (const edit of items) {
+        const normalized = normalizeFileEdit(edit);
+        if (!normalized) {
+            continue;
+        }
+        result.push({
+            kind: normalized.kind,
+            resource: normalized.resource,
+            originalResource: normalized.kind === FileEditKind.Rename ? normalized.beforeUri : undefined,
+            beforeContentUri: normalized.beforeContentUri,
+            afterContentUri: normalized.afterContentUri,
+            undoStopId,
+            diff: edit.diff
+        });
+    }
+    return result;
+}
+
+export { BOOLEAN_FALSE_OPTION_ID, BOOLEAN_TRUE_OPTION_ID, activeTurnToProgress, completedToolCallToEditParts, completedToolCallToSerialized, containsAutomaticReplyAnswer, convertProtocolAnswers, convertProtocolPlanReviewResult, createInputRequestCarousel, createInputRequestPlanReview, fileEditsToExternalEdits, finalizeToolInvocation, formatTurnResponseDetails, getTerminalContent, getUrlInputRequestPresentation, inputRequestResponsePartToProgress, isSubagentTool, isSubagentToolName, makeAhpTerminalToolSessionId, messageAttachmentsToVariableData, messageToRequestOrigin, messageToRequestSource, messageToVariableData, parseAhpTerminalToolSessionId, rawMarkdownToString, rewriteAgentHostLinkTarget, rewriteMarkdownLinks, shouldObserveSubagentChat, stringOrMarkdownToString, systemNotificationToChatPart, toolCallAuthenticationServer, toolCallConfirmationMessages, toolCallStateToInvocation, toolCallStateToPreparedInvocation, toolCallStateToStreamingInvocation, turnsToHistory, updateRunningToolSpecificData, updateStreamingToolInvocation, usageInfoToAutoModeResolution, usageInfoToChatUsage, usageInfoToQuotas };