@codingame/monaco-vscode-workbench-service-override 37.6.0 → 38.0.0

package/vscode/src/vs/sessions/contrib/sessionComparison/browser/sessionComparisonTool.js

@@ -0,0 +1,559 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { Codicon } from '@codingame/monaco-vscode-api/vscode/vs/base/common/codicons';
+import { Disposable, DisposableStore } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/index';
+import { isEqual } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { IConfigurationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service';
+import { ContextKeyExpr } from '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey';
+import { IInstantiationService } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+import { observableConfigValue } from '@codingame/monaco-vscode-api/vscode/vs/platform/observable/common/platformObservableUtils';
+import { ReasoningEffortConfigKey } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/reasoningEffort';
+import { ChatContextKeys } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/actions/chatContextKeys';
+import { isIChatSessionFileChange2 } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService';
+import { ToolDataSource } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService';
+import { ILanguageModelToolsService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/tools/languageModelToolsService.service';
+import { SessionStatus } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/session';
+import { ISessionsManagementService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/sessionsManagement.service';
+import { SessionComparisonParticipantRole, getSessionComparisonAttemptLabel, COMPARE_AGENTS_ENABLED_SETTING, SessionComparisonValidationState, SessionComparisonValidationSource, SESSION_COMPARISON_MANIFEST_LIST_MAX_ITEMS, getBoundedSessionComparisonManifestList, getBoundedSessionComparisonManifestText } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/sessionComparison';
+import { ISessionComparisonService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/sessionComparison.service';
+import { hashSessionIdForTelemetry } from '@codingame/monaco-vscode-api/vscode/vs/sessions/common/sessionsTelemetry';
+import { autorun } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/reactions/autorun';
+
+const CompleteSessionComparisonToolId = "vscode_completeAttemptComparison";
+const ReadSessionComparisonToolId = "vscode_readAttemptComparison";
+const MaxExplanationLength = 240;
+const MaxRationalePointLength = 180;
+let ReadSessionComparisonTool = class ReadSessionComparisonTool {
+    constructor(comparisonService, sessionsManagementService) {
+        this.comparisonService = comparisonService;
+        this.sessionsManagementService = sessionsManagementService;
+    }
+    getToolData() {
+        return {
+            id: ReadSessionComparisonToolId,
+            toolReferenceName: "readAttemptComparison",
+            canBeReferencedInPrompt: true,
+            icon: Codicon.compareChanges,
+            displayName: ( localize(5651, "Read Attempt Comparison")),
+            userDescription: ( localize(5652, "Read the attempts and evidence for an active comparison")),
+            modelDescription: "Read the bounded manifest for an active implementation-attempt comparison. Use this when judging or synthesizing that comparison, before inspecting individual transcripts. It returns the original task, every attempt with a semantic lifecycle status, changed-file evidence status, change summaries, authoritative worktree locations, exact targets for get_session_context, the Judge verdict mapped to attempt numbers when available, and any additional synthesis instructions. Attempt status is one of untitled, inProgress, needsInput, completed, error, or unavailable; only completed means the attempt finished successfully. Terminal commands start in the Judge or synthesis worktree, so explicitly cd to an attempt's listed workingDirectory in every command that inspects or validates it. Read implementation code only from the listed worktrees; transcripts are for rationale or validation evidence. A Judge must review every attempt diff, use get_session_context to identify validation the attempt already completed, never rerun a validation category with a clear reported result, and run only missing targeted validation when needed. If dependencies or build artifacts are unavailable, it must record validation as unavailable without installing dependencies or substituting another validation category. A synthesis agent must resolve the verdict's conflicts and treat additional synthesis instructions as user requirements. It does not return full transcripts or submit a verdict.",
+            source: ToolDataSource.Internal,
+            when: ( ContextKeyExpr.and(ChatContextKeys.enabled)),
+            runsInWorkspace: false,
+            inputSchema: {
+                type: "object",
+                properties: {
+                    comparisonId: {
+                        type: "string",
+                        description: "The comparison ID supplied in the Judge or synthesis prompt."
+                    }
+                },
+                required: ["comparisonId"],
+                additionalProperties: false
+            }
+        };
+    }
+    async prepareToolInvocation(_context, _token) {
+        return {
+            invocationMessage: ( localize(5653, "Reading attempt comparison")),
+            pastTenseMessage: ( localize(5654, "Read attempt comparison"))
+        };
+    }
+    async invoke(invocation, _countTokens, _progress, _token) {
+        const input = parseReadInput(invocation.parameters);
+        if (!input) {
+            return toolError("The comparison manifest input is invalid.");
+        }
+        const comparison = resolveComparison(this.comparisonService, input.comparisonId);
+        if (!comparison) {
+            return toolError(`Comparison '${input.comparisonId}' does not exist.`);
+        }
+        if (!isInvokingParticipant(comparison, invocation, [
+            SessionComparisonParticipantRole.Judge,
+            SessionComparisonParticipantRole.Synthesis
+        ])) {
+            return toolError(
+                "Only the Judge or synthesis session for this comparison can read its manifest."
+            );
+        }
+        const invokingSession = invocation.context?.sessionResource ? this.sessionsManagementService.getSession(invocation.context.sessionResource) : undefined;
+        const allAttemptParticipants = comparison.participants.filter(
+            participant => participant.role === SessionComparisonParticipantRole.Attempt
+        );
+        const attemptNumbers = ( new Map(
+            allAttemptParticipants.map((participant, index) => [participant.id, index + 1])
+        ));
+        const attemptParticipants = allAttemptParticipants.filter(participant => participant.sessionResource);
+        const attempts = attemptParticipants.map(participant => {
+            const session = this.sessionsManagementService.getSession(participant.sessionResource);
+            const changes = session?.mainChat.get().changes.get() ?? [];
+            const changedFiles = changes.slice(0, 200).map(change => ({
+                resource: ( (isIChatSessionFileChange2(change) ? change.uri : change.modifiedUri).toString()),
+                insertions: change.insertions,
+                deletions: change.deletions
+            }));
+            const workspace = session?.workspace.get();
+            const changesSummary = session?.changesSummary?.get();
+            const sessionContextTarget = session && invokingSession && invokingSession.providerId === session.providerId ? this.sessionsManagementService.getSessionContextReference(session.mainChat.get().resource) : undefined;
+            const reasoningEffort = participant.harness.modelConfiguration?.[ReasoningEffortConfigKey];
+            const attemptNumber = attemptNumbers.get(participant.id);
+            return {
+                attemptNumber,
+                label: getSessionComparisonAttemptLabel(participant, attemptNumber),
+                harness: {
+                    agent: participant.harness.label,
+                    model: participant.harness.modelLabel ?? "Default",
+                    reasoningEffort: typeof reasoningEffort === "string" ? reasoningEffort : "default",
+                    permissions: {
+                        id: participant.harness.permissionId ?? "default",
+                        label: participant.harness.permissionLabel ?? "Default"
+                    }
+                },
+                status: getManifestSessionStatus(session?.status.get()),
+                launchError: participant.launchError,
+                sessionContextTarget,
+                sessionContextUnavailableReason: session && !sessionContextTarget ? "Transcript follow-up is unavailable from this Judge host; use the manifest and worktree evidence." : undefined,
+                worktree: workspace ? {
+                    workingDirectory: workspace.folders[0]?.workingDirectory.fsPath,
+                    folders: workspace.folders.map(folder => folder.workingDirectory.fsPath)
+                } : undefined,
+                changesSummary,
+                changedFiles,
+                changedFilesStatus: changes.length > 0 ? "available" : changesSummary?.files === 0 ? "noChanges" : "unavailable",
+                changedFilesTruncated: changes.length > changedFiles.length
+            };
+        });
+        const synthesisPlan = comparison.synthesisPlan ? {
+            instructions: comparison.synthesisPlan.instructions
+        } : undefined;
+        return toolResult(JSON.stringify({
+            comparisonId: comparison.id,
+            originalTask: comparison.prompt,
+            baseBranch: comparison.branch,
+            attempts,
+            verdict: comparison.verdict ? toManifestVerdict(comparison.verdict, attemptNumbers) : undefined,
+            synthesisPlan,
+            next: "Review every completed attempt diff in its authoritative worktree and treat error as failed and inProgress or needsInput as unfinished. Terminal commands start in this Judge or synthesis worktree, not an attempt worktree: explicitly cd to the exact attempt worktree.workingDirectory in every command that inspects or validates it. When changedFilesStatus is unavailable, read the Git diff from that worktree instead. Use get_session_context with an exact attempt sessionContextTarget to identify validation the attempt already completed and for rationale or other non-code evidence; never recover implementation code or paths from a transcript. Do not rerun a validation category with a clear reported result. Run only missing targeted validation when needed. If required dependencies or build artifacts are unavailable, record validation as unavailable without installing or building dependencies or substituting another validation category. Record each validation category as a consistent state and source pair. Submit verdict references using the manifest attemptNumber values; do not copy participant or session UUIDs. During synthesis, resolve every reported conflict and treat synthesisPlan instructions as explicit user requirements. Resolve dependencies coherently rather than copying hunks mechanically. Do not modify any attempt, inspect another checkout, discover sessions, guess references, or create sessions."
+        }));
+    }
+};
+ReadSessionComparisonTool = ( __decorate([( __param(0, ISessionComparisonService)), ( __param(1, ISessionsManagementService))], ReadSessionComparisonTool));
+let CompleteSessionComparisonTool = class CompleteSessionComparisonTool {
+    constructor(comparisonService) {
+        this.comparisonService = comparisonService;
+    }
+    getToolData() {
+        return {
+            id: CompleteSessionComparisonToolId,
+            toolReferenceName: "completeAttemptComparison",
+            canBeReferencedInPrompt: true,
+            icon: Codicon.compareChanges,
+            displayName: ( localize(5655, "Complete Attempt Comparison")),
+            userDescription: ( localize(5656, "Submit the judge's structured attempt comparison")),
+            modelDescription: "Submit the final structured verdict for an active implementation-attempt comparison. Use this after reviewing every referenced attempt diff and running any missing targeted validation needed for a reliable recommendation. Reference attempts only by the attemptNumber values returned by readAttemptComparison; do not use participant or session UUIDs. Keep explanation to one concise sentence. Provide exactly one concise rationale point in this order: comparison, validation, codeQuality, and solution. Each point must cite concrete evidence and stay within the schema length limit. For each validation category, provide one consistent state and source evidence pair. Known passed or failed results must come from the attempt report or a Judge run; unavailable evidence cannot claim a known result. This persists an advisory verdict; synthesis only starts through an explicit user action. If invalid input is rejected, correct the reported fields and retry; do not submit again after success.",
+            source: ToolDataSource.Internal,
+            when: ( ContextKeyExpr.and(ChatContextKeys.enabled)),
+            runsInWorkspace: false,
+            inputSchema: {
+                type: "object",
+                properties: {
+                    comparisonId: {
+                        type: "string",
+                        description: "The comparison ID supplied in the judge prompt."
+                    },
+                    recommendedAttemptNumber: {
+                        type: "integer",
+                        minimum: 1,
+                        description: "The attemptNumber of the strongest attempt from readAttemptComparison."
+                    },
+                    explanation: {
+                        type: "string",
+                        minLength: 1,
+                        maxLength: MaxExplanationLength,
+                        description: "One concise sentence summarizing why the winning attempt is strongest."
+                    },
+                    rationale: {
+                        type: "object",
+                        description: "Four categorized, concise reasons why the recommended attempt won.",
+                        properties: {
+                            comparison: rationalePointSchema("The decisive advantage over the other attempts."),
+                            validation: rationalePointSchema("The strongest concrete validation evidence."),
+                            codeQuality: rationalePointSchema("Why the implementation is well scoped and maintainable."),
+                            solution: rationalePointSchema("What the solution gets right.")
+                        },
+                        required: ["comparison", "validation", "codeQuality", "solution"],
+                        additionalProperties: false
+                    },
+                    conflicts: {
+                        type: "array",
+                        description: "Cross-attempt conflicts or incompatible design choices that synthesis must resolve.",
+                        items: {
+                            type: "string"
+                        }
+                    },
+                    attempts: {
+                        type: "array",
+                        description: "One structured verdict for each attempt.",
+                        items: {
+                            type: "object",
+                            properties: {
+                                attemptNumber: {
+                                    type: "integer",
+                                    minimum: 1,
+                                    description: "The attemptNumber from readAttemptComparison."
+                                },
+                                summary: {
+                                    type: "string"
+                                },
+                                validation: {
+                                    type: "object",
+                                    properties: {
+                                        tests: validationEvidenceSchema(),
+                                        build: validationEvidenceSchema(),
+                                        lint: validationEvidenceSchema(),
+                                        diagnostics: validationEvidenceSchema()
+                                    },
+                                    required: ["tests", "build", "lint", "diagnostics"],
+                                    additionalProperties: false
+                                },
+                                unresolvedIssues: {
+                                    type: "array",
+                                    items: {
+                                        type: "string"
+                                    }
+                                },
+                                notableDifferences: {
+                                    type: "array",
+                                    description: "The strongest reusable points from this attempt, especially when it is not recommended.",
+                                    items: {
+                                        type: "string"
+                                    }
+                                }
+                            },
+                            required: [
+                                "attemptNumber",
+                                "summary",
+                                "validation",
+                                "unresolvedIssues",
+                                "notableDifferences"
+                            ],
+                            additionalProperties: false
+                        }
+                    }
+                },
+                required: [
+                    "comparisonId",
+                    "recommendedAttemptNumber",
+                    "explanation",
+                    "rationale",
+                    "conflicts",
+                    "attempts"
+                ],
+                additionalProperties: false
+            }
+        };
+    }
+    async prepareToolInvocation(_context, _token) {
+        return {
+            invocationMessage: ( localize(5657, "Submitting attempt comparison")),
+            pastTenseMessage: ( localize(5658, "Submitted attempt comparison"))
+        };
+    }
+    async invoke(invocation, _countTokens, _progress, _token) {
+        const input = parseInput(invocation.parameters);
+        if (!input) {
+            return toolError(
+                "The comparison verdict input is invalid. Keep explanation to one sentence, provide concise comparison, validation, codeQuality, and solution rationale points, and use a consistent state and source pair for every validation category."
+            );
+        }
+        const comparison = resolveComparison(this.comparisonService, input.comparisonId);
+        if (!comparison) {
+            return toolError(`Comparison '${input.comparisonId}' does not exist.`);
+        }
+        if (!isInvokingParticipant(comparison, invocation, [SessionComparisonParticipantRole.Judge])) {
+            return toolError("Only the judge session for this comparison can submit its verdict.");
+        }
+        const allAttemptParticipants = comparison.participants.filter(
+            participant => participant.role === SessionComparisonParticipantRole.Attempt
+        );
+        const attemptParticipantsByNumber = ( new Map());
+        for (const [index, participant] of allAttemptParticipants.entries()) {
+            if (participant.sessionResource) {
+                attemptParticipantsByNumber.set(index + 1, participant);
+            }
+        }
+        const attemptParticipants = [...( attemptParticipantsByNumber.values())];
+        const validAttemptNumbers = ( new Set(( attemptParticipantsByNumber.keys())));
+        if (!Number.isInteger(input.recommendedAttemptNumber) || !( validAttemptNumbers.has(input.recommendedAttemptNumber)) || input.attempts.length !== attemptParticipants.length || ( input.attempts.some(attempt => !Number.isInteger(attempt.attemptNumber) || !( validAttemptNumbers.has(attempt.attemptNumber)))) || ( new Set(input.attempts.map(attempt => attempt.attemptNumber))).size !== input.attempts.length) {
+            return toolError(
+                "The verdict must recommend an attemptNumber and include exactly one finding for every attemptNumber returned by readAttemptComparison."
+            );
+        }
+        const verdict = {
+            recommendedParticipantId: attemptParticipantsByNumber.get(input.recommendedAttemptNumber).id,
+            explanation: input.explanation,
+            rationale: input.rationale,
+            conflicts: input.conflicts,
+            attempts: input.attempts.map(attempt => {
+                const {
+                    attemptNumber,
+                    ...finding
+                } = attempt;
+                return {
+                    participantId: attemptParticipantsByNumber.get(attemptNumber).id,
+                    ...finding
+                };
+            })
+        };
+        this.comparisonService.submitVerdict(comparison.id, verdict);
+        const result = toolResult(JSON.stringify({
+            status: "submitted",
+            comparisonId: comparison.id
+        }));
+        result.toolResultMessage = ( localize(5659, "Submitted attempt comparison"));
+        return result;
+    }
+};
+CompleteSessionComparisonTool = ( __decorate([( __param(0, ISessionComparisonService))], CompleteSessionComparisonTool));
+let SessionComparisonToolContribution = class SessionComparisonToolContribution extends Disposable {
+    static {
+        this.ID = "sessions.contrib.sessionComparisonTool";
+    }
+    constructor(
+        toolsService,
+        instantiationService,
+        comparisonService,
+        configurationService
+    ) {
+        super();
+        this._toolRegistrations = this._register(( new DisposableStore()));
+        this._toolsRegistered = false;
+        const enabled = observableConfigValue(COMPARE_AGENTS_ENABLED_SETTING, false, configurationService);
+        this._register(autorun(reader => {
+            const shouldRegister = enabled.read(reader) || ( comparisonService.comparisons.read(reader).some(comparison => comparison.archivedAt === undefined));
+            if (shouldRegister === this._toolsRegistered) {
+                return;
+            }
+            this._toolsRegistered = shouldRegister;
+            this._toolRegistrations.clear();
+            if (shouldRegister) {
+                this._registerComparisonTools(toolsService, instantiationService);
+            }
+        }));
+    }
+    _registerComparisonTools(toolsService, instantiationService) {
+        const toolSet = this._toolRegistrations.add(toolsService.createToolSet(
+            ToolDataSource.Internal,
+            "vscode_sessionComparison",
+            "sessionComparison",
+            {
+                icon: Codicon.compareChanges,
+                description: ( localize(5660, "Compare implementation attempts")),
+                hiddenInToolsPicker: true
+            }
+        ));
+        const readTool = instantiationService.createInstance(ReadSessionComparisonTool);
+        const readToolData = readTool.getToolData();
+        this._toolRegistrations.add(toolsService.registerTool(readToolData, readTool));
+        this._toolRegistrations.add(toolSet.addTool(readToolData));
+        const tool = instantiationService.createInstance(CompleteSessionComparisonTool);
+        const toolData = tool.getToolData();
+        this._toolRegistrations.add(toolsService.registerTool(toolData, tool));
+        this._toolRegistrations.add(toolSet.addTool(toolData));
+    }
+};
+SessionComparisonToolContribution = ( __decorate([( __param(0, ILanguageModelToolsService)), ( __param(1, IInstantiationService)), ( __param(2, ISessionComparisonService)), ( __param(3, IConfigurationService))], SessionComparisonToolContribution));
+function parseReadInput(value) {
+    return isRecord(value) && typeof value.comparisonId === "string" ? {
+        comparisonId: value.comparisonId
+    } : undefined;
+}
+function isInvokingParticipant(comparison, invocation, roles) {
+    const invokingSession = invocation.context?.sessionResource;
+    return !!invokingSession && ( comparison.participants.some(
+        participant => roles.includes(participant.role) && !!participant.sessionResource && isEqual(invokingSession, participant.sessionResource)
+    ));
+}
+function parseInput(value) {
+    const rationale = isRecord(value) ? parseRationale(value.rationale) : undefined;
+    if (!isRecord(value) || typeof value.comparisonId !== "string" || typeof value.recommendedAttemptNumber !== "number" || !isConciseText(value.explanation, MaxExplanationLength) || !rationale || !isStringArray(value.conflicts) || !Array.isArray(value.attempts) || Object.hasOwn(value, "decisionSections")) {
+        return undefined;
+    }
+    const attempts = [];
+    for (const attempt of value.attempts) {
+        if (!isRecord(attempt) || typeof attempt.attemptNumber !== "number" || typeof attempt.summary !== "string" || !isRecord(attempt.validation) || !isValidationEvidence(attempt.validation.tests) || !isValidationEvidence(attempt.validation.build) || !isValidationEvidence(attempt.validation.lint) || !isValidationEvidence(attempt.validation.diagnostics) || !isStringArray(attempt.unresolvedIssues) || !isStringArray(attempt.notableDifferences)) {
+            return undefined;
+        }
+        attempts.push({
+            attemptNumber: attempt.attemptNumber,
+            summary: attempt.summary,
+            validation: {
+                tests: attempt.validation.tests,
+                build: attempt.validation.build,
+                lint: attempt.validation.lint,
+                diagnostics: attempt.validation.diagnostics
+            },
+            unresolvedIssues: attempt.unresolvedIssues,
+            notableDifferences: attempt.notableDifferences
+        });
+    }
+    return {
+        comparisonId: value.comparisonId,
+        recommendedAttemptNumber: value.recommendedAttemptNumber,
+        explanation: value.explanation,
+        rationale,
+        conflicts: value.conflicts,
+        attempts
+    };
+}
+function parseRationale(value) {
+    if (!isRecord(value) || !isConciseText(value.comparison, MaxRationalePointLength) || !isConciseText(value.validation, MaxRationalePointLength) || !isConciseText(value.codeQuality, MaxRationalePointLength) || !isConciseText(value.solution, MaxRationalePointLength)) {
+        return undefined;
+    }
+    return {
+        comparison: value.comparison,
+        validation: value.validation,
+        codeQuality: value.codeQuality,
+        solution: value.solution
+    };
+}
+function isConciseText(value, maxLength) {
+    return typeof value === "string" && value.trim().length > 0 && value.length <= maxLength && !value.includes("\n");
+}
+function rationalePointSchema(description) {
+    return {
+        type: "string",
+        minLength: 1,
+        maxLength: MaxRationalePointLength,
+        description
+    };
+}
+function getManifestSessionStatus(status) {
+    switch (status) {
+    case SessionStatus.Untitled:
+        return "untitled";
+    case SessionStatus.InProgress:
+        return "inProgress";
+    case SessionStatus.NeedsInput:
+        return "needsInput";
+    case SessionStatus.Completed:
+        return "completed";
+    case SessionStatus.Error:
+        return "error";
+    case undefined:
+        return "unavailable";
+    }
+}
+function validationEvidenceSchema() {
+    return {
+        description: "A consistent validation state and evidence source pair.",
+        oneOf: [validationEvidenceVariant([
+            SessionComparisonValidationState.Passed,
+            SessionComparisonValidationState.Failed
+        ], [
+            SessionComparisonValidationSource.AttemptReport,
+            SessionComparisonValidationSource.JudgeRun
+        ]), validationEvidenceVariant([
+            SessionComparisonValidationState.NotRun,
+            SessionComparisonValidationState.Unknown
+        ], [
+            SessionComparisonValidationSource.AttemptReport,
+            SessionComparisonValidationSource.JudgeRun,
+            SessionComparisonValidationSource.Unavailable
+        ]), validationEvidenceVariant(
+            [SessionComparisonValidationState.NotApplicable],
+            [SessionComparisonValidationSource.NotApplicable]
+        )]
+    };
+}
+function validationEvidenceVariant(states, sources) {
+    return {
+        type: "object",
+        properties: {
+            state: {
+                type: "string",
+                enum: [...states]
+            },
+            source: {
+                type: "string",
+                enum: [...sources]
+            }
+        },
+        required: ["state", "source"],
+        additionalProperties: false
+    };
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}
+function isStringArray(value) {
+    return Array.isArray(value) && value.every(item => typeof item === "string");
+}
+function isValidationEvidence(value) {
+    if (!isRecord(value)) {
+        return false;
+    }
+    switch (value.state) {
+    case SessionComparisonValidationState.Passed:
+    case SessionComparisonValidationState.Failed:
+        return value.source === SessionComparisonValidationSource.AttemptReport || value.source === SessionComparisonValidationSource.JudgeRun;
+    case SessionComparisonValidationState.NotRun:
+    case SessionComparisonValidationState.Unknown:
+        return value.source === SessionComparisonValidationSource.AttemptReport || value.source === SessionComparisonValidationSource.JudgeRun || value.source === SessionComparisonValidationSource.Unavailable;
+    case SessionComparisonValidationState.NotApplicable:
+        return value.source === SessionComparisonValidationSource.NotApplicable;
+    default:
+        return false;
+    }
+}
+function toManifestVerdict(verdict, attemptNumbers) {
+    const recommendedAttemptNumber = attemptNumbers.get(verdict.recommendedParticipantId);
+    if (!recommendedAttemptNumber) {
+        return undefined;
+    }
+    return {
+        recommendedAttemptNumber,
+        explanation: getBoundedSessionComparisonManifestText(verdict.explanation),
+        rationale: verdict.rationale,
+        conflicts: getBoundedSessionComparisonManifestList(verdict.conflicts),
+        attempts: verdict.attempts.slice(0, SESSION_COMPARISON_MANIFEST_LIST_MAX_ITEMS).flatMap(attempt => {
+            const attemptNumber = attemptNumbers.get(attempt.participantId);
+            return attemptNumber ? [{
+                attemptNumber,
+                summary: getBoundedSessionComparisonManifestText(attempt.summary),
+                validation: attempt.validation,
+                unresolvedIssues: getBoundedSessionComparisonManifestList(attempt.unresolvedIssues),
+                notableDifferences: getBoundedSessionComparisonManifestList(attempt.notableDifferences)
+            }] : [];
+        })
+    };
+}
+function toolResult(value) {
+    return {
+        content: [{
+            kind: "text",
+            value
+        }]
+    };
+}
+function toolError(message) {
+    return {
+        content: [{
+            kind: "text",
+            value: message
+        }],
+        toolResultError: message,
+        toolResultMessage: ( localize(5661, "Attempt comparison submission failed"))
+    };
+}
+function resolveComparison(comparisonService, comparisonId) {
+    const direct = comparisonService.getComparison(comparisonId);
+    if (direct) {
+        return direct;
+    }
+    return comparisonService.comparisons.get().find(comparison => hashSessionIdForTelemetry(comparison.id) === comparisonId);
+}
+
+export { CompleteSessionComparisonTool, ReadSessionComparisonTool, SessionComparisonToolContribution };

package/vscode/src/vs/sessions/contrib/sessionComparison/browser/sessionComparisonViewService.d.ts

@@ -0,0 +1,12 @@
+import { ISessionsService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsService.service";
+import { ISessionComparisonService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/sessionComparison.service";
+import { ISessionsManagementService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/sessionsManagement.service";
+import { ISessionComparisonViewService } from "@codingame/monaco-vscode-api/vscode/vs/sessions/contrib/sessionComparison/browser/sessionComparisonViewService.service";
+export declare class SessionComparisonViewService implements ISessionComparisonViewService {
+    private readonly comparisonService;
+    private readonly managementService;
+    private readonly sessionsService;
+    readonly _serviceBrand: undefined;
+    constructor(comparisonService: ISessionComparisonService, managementService: ISessionsManagementService, sessionsService: ISessionsService);
+    open(comparisonId: string): Promise<void>;
+}

package/vscode/src/vs/sessions/contrib/sessionComparison/browser/sessionComparisonViewService.js

@@ -0,0 +1,38 @@
+
+import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { ISessionsService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/browser/sessionsService.service';
+import { getSessionComparisonParticipantsInDisplayOrder, SessionComparisonParticipantRole } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/sessionComparison';
+import { ISessionComparisonService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/sessionComparison.service';
+import { ISessionsManagementService } from '@codingame/monaco-vscode-api/vscode/vs/sessions/services/sessions/common/sessionsManagement.service';
+
+let SessionComparisonViewService = class SessionComparisonViewService {
+    constructor(comparisonService, managementService, sessionsService) {
+        this.comparisonService = comparisonService;
+        this.managementService = managementService;
+        this.sessionsService = sessionsService;
+    }
+    async open(comparisonId) {
+        const comparison = this.comparisonService.getComparison(comparisonId);
+        if (!comparison) {
+            throw ( new Error(( localize(5662, "This comparison is no longer available."))));
+        }
+        const availableAttempts = getSessionComparisonParticipantsInDisplayOrder(comparison.participants).flatMap(participant => {
+            if (participant.role !== SessionComparisonParticipantRole.Attempt) {
+                return [];
+            }
+            if (!participant.sessionResource) {
+                return [];
+            }
+            const session = this.managementService.getSession(participant.sessionResource);
+            return session ? [session] : [];
+        });
+        if (!availableAttempts.length) {
+            throw ( new Error(( localize(5663, "No comparison attempts are available to open."))));
+        }
+        await this.sessionsService.openSessionsInGrid(availableAttempts);
+    }
+};
+SessionComparisonViewService = ( __decorate([( __param(0, ISessionComparisonService)), ( __param(1, ISessionsManagementService)), ( __param(2, ISessionsService))], SessionComparisonViewService));
+
+export { SessionComparisonViewService };