@theia/ai-ide 1.72.0-next.59 → 1.72.0

package/src/browser/user-interaction-tool-renderer.tsx

@@ -33,6 +33,7 @@ import {
     UserInteractionLink,
     UserInteractionResult,
     UserInteractionStep,
+    UserInteractionStepResult,
     buildDiffLabel,
     isEmptyContentRef,
     parseUserInteractionArgs,
@@ -41,46 +42,57 @@ import {
     resolveContentRef,
 } from '../common/user-interaction-tool';
 
+interface StepState {
+    value?: string;
+    comments: string[];
+}
+
 interface UserInteractionComponentProps {
     args: UserInteractionArgs;
     toolCallId: string;
     tool: UserInteractionTool;
     finished: boolean;
     canceled: boolean;
+    result: UserInteractionResult | undefined;
     /**
-     * Whether the parent response has completed (including restoration). When the
-     * response is complete but no `result` was persisted, the interaction is treated
-     * as canceled because there is no longer a live agent waiting for input.
+     * Called whenever the user changes any step state. The parent persists this partial
+     * result on the response (so it survives chat-session reloads) and pushes it to the
+     * tool (so a synchronous cancellation can return it instead of all-skipped).
      */
-    responseComplete: boolean;
-    result: UserInteractionResult | undefined;
+    onPartialResult: (result: UserInteractionResult) => void;
     openerService: OpenerService;
 }
 
-interface StepState {
-    value?: string;
-    comments: string[];
-}
-
 const UserInteractionComponent: React.FC<UserInteractionComponentProps> = ({
-    args, toolCallId, tool, finished, canceled, responseComplete, result, openerService
+    args, toolCallId, tool, finished, canceled, result, onPartialResult, openerService
 }) => {
     const steps = args.interactions;
     const stepCount = steps.length;
     const [currentStep, setCurrentStep] = React.useState(0);
-    const [stepStates, setStepStates] = React.useState<StepState[]>(() => steps.map(() => ({ comments: [] })));
+    // The tool's result (partial or final) is the single source of truth for step states.
+    const [stepStates, setStepStates] = React.useState<StepState[]>(() => {
+        if (result) {
+            return steps.map((_, i) => ({
+                value: result.steps[i]?.value,
+                comments: result.steps[i]?.comments ? [...result.steps[i].comments!] : []
+            }));
+        }
+        return steps.map(() => ({ comments: [] }));
+    });
+    // Mirror stepStates into a ref so synchronous readers (cancellation fallback,
+    // terminal handlers) always see the latest value. The ref is updated synchronously
+    // by every code path that writes to stepStates, which also keeps these handlers
+    // free of `stepStates` deps and avoids state-updater side effects.
+    const stepStatesRef = React.useRef(stepStates);
     const [pendingComment, setPendingComment] = React.useState('');
 
     const activeStep: UserInteractionStep | undefined = steps[currentStep];
     const isLastStep = currentStep === stepCount - 1;
     const messageRef = useMarkdownRendering(activeStep?.message ?? '', openerService);
 
-    // A parent response that completed without delivering a tool result means the
-    // interaction was restored from a serialized "waiting for input" state. The
-    // agent that was waiting is no longer running, so it must be treated as
-    // canceled and all inputs locked.
-    const restoredWithoutResult = responseComplete && !result;
-    const isFinal = finished || !!result || canceled || restoredWithoutResult;
+    // A finished tool call has no live handler anymore (completion, cancellation, or
+    // restoration of a previously-pending interaction). Lock all inputs in that case.
+    const isFinal = finished || canceled;
 
     // Auto-open the active step's links the first time the user reaches it.
     // Going Back and then Forward must not re-open them.
@@ -92,28 +104,40 @@ const UserInteractionComponent: React.FC<UserInteractionComponentProps> = ({
         visitedStepsRef.current.add(currentStep);
         const links = activeStep.links ?? [];
         for (const link of links) {
-            if (link.autoOpen !== false) {
+            if (link.autoOpen) {
                 tool.openLink(link).catch(err => console.warn('Failed to auto-open user-interaction link:', err));
             }
         }
     }, [currentStep, activeStep, isFinal, tool]);
 
-    const persistStepState = React.useCallback((stepIndex: number, state: StepState) => {
-        tool.setStepResult(toolCallId, stepIndex, {
-            value: state.value,
-            comments: state.comments.length > 0 ? state.comments : undefined
-        });
-    }, [tool, toolCallId]);
+    const buildResult = React.useCallback((completed: boolean, states: StepState[]): UserInteractionResult => ({
+        completed,
+        steps: steps.map((step, i) => {
+            const state = states[i];
+            const stepResult: UserInteractionStepResult = { title: step.title };
+            if (state?.value !== undefined) {
+                stepResult.value = state.value;
+            }
+            if (state?.comments && state.comments.length > 0) {
+                stepResult.comments = [...state.comments];
+            }
+            // For partial/cancel results, mark untouched steps as skipped so the LLM
+            // can distinguish "answered" from "not answered" if the interaction never
+            // completes.
+            if (!completed && stepResult.value === undefined && stepResult.comments === undefined) {
+                stepResult.skipped = true;
+            }
+            return stepResult;
+        })
+    }), [steps]);
 
     const updateStepState = React.useCallback((stepIndex: number, updater: (prev: StepState) => StepState) => {
-        setStepStates(prev => {
-            const next = prev.slice();
-            const updated = updater(prev[stepIndex]);
-            next[stepIndex] = updated;
-            persistStepState(stepIndex, updated);
-            return next;
-        });
-    }, [persistStepState]);
+        const next = stepStatesRef.current.slice();
+        next[stepIndex] = updater(next[stepIndex]);
+        stepStatesRef.current = next;
+        setStepStates(next);
+        onPartialResult(buildResult(false, next));
+    }, [buildResult, onPartialResult]);
 
     const isSingleStep = stepCount === 1;
     const hasOptions = !!activeStep?.options && activeStep.options.length > 0;
@@ -123,19 +147,17 @@ const UserInteractionComponent: React.FC<UserInteractionComponentProps> = ({
             return;
         }
         if (isSingleStep) {
-            setStepStates(prev => {
-                const next = prev.slice();
-                next[0] = { ...prev[0], value };
-                return next;
-            });
-            tool.completeInteractionWith(toolCallId, 0, { value });
+            const next: StepState[] = [{ ...stepStatesRef.current[0], value }];
+            stepStatesRef.current = next;
+            setStepStates(next);
+            tool.completeInteraction(toolCallId, buildResult(true, next));
             return;
         }
         updateStepState(currentStep, prev => ({
             ...prev,
             value: prev.value === value ? undefined : value
         }));
-    }, [currentStep, isFinal, isSingleStep, tool, toolCallId, updateStepState]);
+    }, [buildResult, currentStep, isFinal, isSingleStep, tool, toolCallId, updateStepState]);
 
     const handleAddComment = React.useCallback(() => {
         const trimmed = pendingComment.trim();
@@ -177,13 +199,13 @@ const UserInteractionComponent: React.FC<UserInteractionComponentProps> = ({
     const handleAdvance = React.useCallback(() => {
         if (isLastStep) {
             if (!isFinal) {
-                tool.completeInteraction(toolCallId);
+                tool.completeInteraction(toolCallId, buildResult(true, stepStatesRef.current));
             }
             return;
         }
         setCurrentStep(idx => idx + 1);
         setPendingComment('');
-    }, [isFinal, isLastStep, tool, toolCallId]);
+    }, [buildResult, isFinal, isLastStep, tool, toolCallId]);
 
     const handleBack = React.useCallback(() => {
         if (currentStep === 0) {
@@ -211,14 +233,14 @@ const UserInteractionComponent: React.FC<UserInteractionComponentProps> = ({
                 <span className={codicon('comment-discussion')} />
                 <span className='user-interaction-tool title'>{activeStep.title}</span>
                 {(() => {
-                    // The tool's own result is authoritative: a completed
-                    // interaction must stay "Completed" even if the chat
-                    // session is canceled later. A response that completed
-                    // without a result indicates the interaction was restored
-                    // from a "waiting" state and is treated as canceled.
+                    // A completed result is authoritative and persists even if the
+                    // chat is later canceled. While the tool is live we may already
+                    // have a partial result (`completed: false`) so distinguish
+                    // "still waiting" from "canceled" using `finished`/`canceled`:
+                    // both are only true once no live handler is around.
                     const status: 'completed' | 'canceled' | 'waiting' =
                         result?.completed === true ? 'completed' :
-                            result?.completed === false || canceled || restoredWithoutResult ? 'canceled' :
+                            finished || canceled ? 'canceled' :
                                 'waiting';
                     if (status === 'completed') {
                         return (
@@ -515,8 +537,11 @@ export class UserInteractionToolRenderer implements ChatResponsePartRenderer<Too
                 tool={this.userInteractionTool}
                 finished={response.finished}
                 canceled={parentNode.response.isCanceled}
-                responseComplete={parentNode.response.isComplete}
                 result={parseUserInteractionResult(response.result)}
+                onPartialResult={partial => {
+                    this.userInteractionTool.recordPartial(response.id!, partial);
+                    response.updateResult(JSON.stringify(partial));
+                }}
                 openerService={this.openerService}
                 toolConfirmation={{
                     response,

package/src/browser/user-interaction-tool.spec.ts

@@ -14,6 +14,10 @@
 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
 // *****************************************************************************
 
+import { enableJSDOM } from '@theia/core/lib/browser/test/jsdom';
+let disableJSDOM = enableJSDOM();
+import { FrontendApplicationConfigProvider } from '@theia/core/lib/browser/frontend-application-config-provider';
+FrontendApplicationConfigProvider.set({});
 import { expect } from 'chai';
 import * as sinon from 'sinon';
 import { Container } from '@theia/core/shared/inversify';
@@ -28,6 +32,8 @@ import { CancellationTokenSource } from '@theia/core/lib/common/cancellation';
 import { MEMORY_TEXT, MEMORY_TEXT_READONLY, ResourceProvider } from '@theia/core/lib/common/resource';
 import { DiffUris } from '@theia/core/lib/browser/diff-uris';
 
+disableJSDOM();
+
 const singleStepArgs = (overrides: Record<string, unknown> = {}) => JSON.stringify({
     interactions: [{
         title: 'Choose',
@@ -39,6 +45,12 @@ const singleStepArgs = (overrides: Record<string, unknown> = {}) => JSON.stringi
 
 const parseResult = (raw: unknown): UserInteractionResult => JSON.parse(raw as string);
 
+const makeMockRepo = () => ({
+    provider: { id: 'git', rootUri: 'file:///workspace' },
+    toUriAtRef: (fileUri: URI, ref: string) =>
+        fileUri.withScheme('git').withQuery(JSON.stringify({ path: fileUri.path.fsPath(), ref }))
+});
+
 describe('UserInteractionTool', () => {
     let container: Container;
     let tool: UserInteractionTool;
@@ -49,6 +61,14 @@ describe('UserInteractionTool', () => {
     let mockResourceProvider: sinon.SinonStub;
     const workspaceRoot = new URI('file:///workspace');
 
+    before(() => {
+        disableJSDOM = enableJSDOM();
+    });
+
+    after(() => {
+        disableJSDOM();
+    });
+
     beforeEach(() => {
         container = new Container();
 
@@ -111,12 +131,14 @@ describe('UserInteractionTool', () => {
         expect(JSON.parse(result as string).error).to.equal('No tool call ID available');
     });
 
-    it('should return single-step result on completion', async () => {
+    it('should resolve the handler with the result passed to completeInteraction', async () => {
         const handler = tool.getTool().handler;
         const handlerPromise = handler(singleStepArgs(), { toolCallId: 'call-1' });
 
-        tool.setStepResult('call-1', 0, { value: 'b' });
-        tool.completeInteraction('call-1');
+        tool.completeInteraction('call-1', {
+            completed: true,
+            steps: [{ title: 'Choose', value: 'b' }]
+        });
 
         const result = parseResult(await handlerPromise);
         expect(result.completed).to.be.true;
@@ -124,18 +146,7 @@ describe('UserInteractionTool', () => {
         expect(result.steps[0]).to.deep.equal({ title: 'Choose', value: 'b' });
     });
 
-    it('should atomically set and complete via completeInteractionWith', async () => {
-        const handler = tool.getTool().handler;
-        const handlerPromise = handler(singleStepArgs(), { toolCallId: 'call-with' });
-
-        tool.completeInteractionWith('call-with', 0, { value: 'a' });
-
-        const result = parseResult(await handlerPromise);
-        expect(result.completed).to.be.true;
-        expect(result.steps[0]).to.deep.equal({ title: 'Choose', value: 'a' });
-    });
-
-    it('should accumulate per-step state across multiple steps', async () => {
+    it('should forward multi-step results verbatim', async () => {
         const handler = tool.getTool().handler;
         const args = JSON.stringify({
             interactions: [
@@ -146,10 +157,14 @@ describe('UserInteractionTool', () => {
         });
         const handlerPromise = handler(args, { toolCallId: 'call-multi' });
 
-        tool.setStepResult('call-multi', 0, { comments: ['nice summary'] });
-        tool.setStepResult('call-multi', 1, { value: 'approve', comments: ['fix on line 42'] });
-        tool.setStepResult('call-multi', 2, {});
-        tool.completeInteraction('call-multi');
+        tool.completeInteraction('call-multi', {
+            completed: true,
+            steps: [
+                { title: 'Overview', comments: ['nice summary'] },
+                { title: 'Area 1', value: 'approve', comments: ['fix on line 42'] },
+                { title: 'Area 2' }
+            ]
+        });
 
         const result = parseResult(await handlerPromise);
         expect(result.completed).to.be.true;
@@ -159,29 +174,24 @@ describe('UserInteractionTool', () => {
         expect(result.steps[2]).to.deep.equal({ title: 'Area 2' });
     });
 
-    it('should ignore setStepResult after completion', async () => {
+    it('should ignore completeInteraction calls after the interaction resolved', async () => {
         const handler = tool.getTool().handler;
         const handlerPromise = handler(singleStepArgs(), { toolCallId: 'call-late' });
-        tool.setStepResult('call-late', 0, { value: 'a' });
-        tool.completeInteraction('call-late');
+        tool.completeInteraction('call-late', {
+            completed: true,
+            steps: [{ title: 'Choose', value: 'a' }]
+        });
         const result = parseResult(await handlerPromise);
         expect(result.steps[0].value).to.equal('a');
         // Late call must not throw or change anything
-        tool.setStepResult('call-late', 0, { value: 'b' });
+        tool.completeInteraction('call-late', {
+            completed: true,
+            steps: [{ title: 'Choose', value: 'b' }]
+        });
         // No assertion needed beyond ensuring no exception
     });
 
-    it('should ignore setStepResult for out-of-range step index', async () => {
-        const handler = tool.getTool().handler;
-        const handlerPromise = handler(singleStepArgs(), { toolCallId: 'call-range' });
-        tool.setStepResult('call-range', 5, { value: 'x' });
-        tool.setStepResult('call-range', -1, { value: 'y' });
-        tool.completeInteraction('call-range');
-        const result = parseResult(await handlerPromise);
-        expect(result.steps[0]).to.deep.equal({ title: 'Choose' });
-    });
-
-    it('should return partial results with completed=false on cancellation', async () => {
+    it('should resolve with the renderer-supplied partial on cancellation', async () => {
         const handler = tool.getTool().handler;
         const cts = new CancellationTokenSource();
         const args = JSON.stringify({
@@ -193,8 +203,17 @@ describe('UserInteractionTool', () => {
         });
         const handlerPromise = handler(args, { toolCallId: 'call-cancel', cancellationToken: cts.token });
 
-        tool.setStepResult('call-cancel', 0, { comments: ['first done'] });
-        tool.setStepResult('call-cancel', 1, { value: 'whatever' });
+        // Wait a microtask so the handler has registered the pending interaction.
+        await Promise.resolve();
+        // Simulate the renderer pushing the latest partial state.
+        tool.recordPartial('call-cancel', {
+            completed: false,
+            steps: [
+                { title: 'Step A', comments: ['first done'] },
+                { title: 'Step B', value: 'whatever' },
+                { title: 'Step C', skipped: true }
+            ]
+        });
         cts.cancel();
 
         const result = parseResult(await handlerPromise);
@@ -204,7 +223,7 @@ describe('UserInteractionTool', () => {
         expect(result.steps[2].skipped).to.be.true;
     });
 
-    it('should mark all steps as skipped if user did nothing before cancellation', async () => {
+    it('should fall back to all-skipped when no renderer claims the cancellation', async () => {
         const handler = tool.getTool().handler;
         const cts = new CancellationTokenSource();
         const args = JSON.stringify({
@@ -231,11 +250,8 @@ describe('UserInteractionTool', () => {
             interactions: [{ title: 'Q2', message: 'second', options: [{ text: 'B', value: 'b' }] }]
         }), { toolCallId: 'call-p2' });
 
-        tool.setStepResult('call-p2', 0, { value: 'b' });
-        tool.completeInteraction('call-p2');
-
-        tool.setStepResult('call-p1', 0, { value: 'a' });
-        tool.completeInteraction('call-p1');
+        tool.completeInteraction('call-p2', { completed: true, steps: [{ title: 'Q2', value: 'b' }] });
+        tool.completeInteraction('call-p1', { completed: true, steps: [{ title: 'Q1', value: 'a' }] });
 
         expect(parseResult(await promise1).steps[0].value).to.equal('a');
         expect(parseResult(await promise2).steps[0].value).to.equal('b');
@@ -257,6 +273,19 @@ describe('UserInteractionTool', () => {
         expect(openCall.args[1]).to.deep.equal({ selection: undefined });
     });
 
+    it('should open a file link when rightRef is an invalid placeholder', async () => {
+        await tool.openLink({
+            ref: { path: 'README.md', line: 1 },
+            rightRef: { path: '' }
+        });
+
+        expect((mockEditorManager.open as sinon.SinonStub).calledOnce).to.be.true;
+        expect((mockOpenerService.getOpener as sinon.SinonStub).called).to.be.false;
+        const openCall = (mockEditorManager.open as sinon.SinonStub).getCall(0);
+        expect(openCall.args[0].toString()).to.equal('file:///workspace/README.md');
+        expect(openCall.args[1]).to.deep.equal({ selection: { start: { line: 0, character: 0 } } });
+    });
+
     it('should open a diff link with custom label', async () => {
         await tool.openLink({ ref: 'src/old.ts', rightRef: 'src/new.ts', label: 'My Diff' });
         expect((mockOpenerService.getOpener as sinon.SinonStub).called).to.be.true;
@@ -290,8 +319,7 @@ describe('UserInteractionTool', () => {
             };
         });
 
-        const mockRepo = { provider: { id: 'git', rootUri: 'file:///workspace' } };
-        (mockScmService.findRepository as sinon.SinonStub).returns(mockRepo);
+        (mockScmService.findRepository as sinon.SinonStub).returns(makeMockRepo());
 
         await tool.openLink({
             ref: { path: 'src/new-file.ts', gitRef: 'abc123' },
@@ -322,8 +350,7 @@ describe('UserInteractionTool', () => {
             };
         });
 
-        const mockRepo = { provider: { id: 'git', rootUri: 'file:///workspace' } };
-        (mockScmService.findRepository as sinon.SinonStub).returns(mockRepo);
+        (mockScmService.findRepository as sinon.SinonStub).returns(makeMockRepo());
 
         await tool.openLink({
             ref: { path: 'src/deleted-file.ts', gitRef: 'abc123' },

package/src/browser/user-interaction-tool.ts

@@ -32,9 +32,9 @@ import {
     UserInteractionLink,
     UserInteractionResult,
     UserInteractionStep,
-    UserInteractionStepResult,
     buildDiffLabel,
     isEmptyContentRef,
+    normalizeUserInteractionLink,
     parseUserInteractionArgs,
     resolveContentRef
 } from '../common/user-interaction-tool';
@@ -42,8 +42,13 @@ import {
 interface PendingInteraction {
     deferred: Deferred<string>;
     steps: UserInteractionStep[];
-    stepResults: UserInteractionStepResult[];
     resolved: boolean;
+    /**
+     * Latest partial result pushed by the renderer via {@link UserInteractionTool.recordPartial}.
+     * Used to resolve the handler with what the user has collected so far when the interaction
+     * is canceled. If absent (no renderer mounted) the tool resolves with all steps skipped.
+     */
+    latestPartial?: UserInteractionResult;
 }
 
 // Schemas are module-level constants so they are built once at load time
@@ -111,18 +116,21 @@ const STEP_SCHEMA: ToolRequestParameterProperty = {
                     },
                     rightRef: {
                         ...CONTENT_REF_SCHEMA,
-                        description: 'Optional right-side content reference for diff views. '
+                        description: 'Right-side content reference for a diff view. '
+                            + 'Only provide this when the step should show a diff; omit it entirely for a single file link. '
                             + 'Provide "path" for a real file, or "empty": true for files that no longer exist.'
                     },
                     label: { type: 'string', description: 'Optional label for the link or diff tab.' },
                     autoOpen: {
                         type: 'boolean',
-                        description: 'Whether to automatically open the file/diff when this step becomes active. Defaults to true.'
+                        description: 'Whether to automatically open the file/diff when this step becomes active. Defaults to false; '
+                            + 'set to true only when the link is essential context the user must see immediately.'
                     }
                 },
                 required: ['ref']
             },
-            description: 'Optional links to files or diffs to show alongside this step.'
+            description: 'Optional links to files or diffs to show alongside this step. '
+                + 'Use "ref" alone for a single file link. Add "rightRef" only when the step should show a diff.'
         }
     },
     required: ['title', 'message']
@@ -134,18 +142,19 @@ const TOOL_PARAMETERS: ToolRequestParameters = {
         interactions: {
             type: 'array',
             items: STEP_SCHEMA,
-            description: 'Ordered list of wizard steps. The user walks through them sequentially without a back button.'
+            description: 'Ordered list of interaction steps. The user walks through them sequentially and can revisit previous steps.'
         }
     },
     required: ['interactions']
 };
 
-const TOOL_DESCRIPTION = 'Present an interactive interaction to the user. Each step has a title, a markdown message, optional option buttons, '
-    + 'and optional file/diff links that auto-open when the step is reached. '
-    + 'Single-step behavior: a single-step interaction with options waits for the user to pick one option, which immediately completes the interaction; '
-    + 'a single-step interaction without options is purely informational and is auto-completed by the tool '
-    + '(do not promise the user a "Finish" or "Next" button — there is none, and no comments can be entered). '
-    + 'Multi-step behavior: the user advances through steps with a "Next" button (or "Finish" on the last step), can navigate freely between steps, '
+const TOOL_DESCRIPTION = 'Present an interactive user interaction. Each step has a title, a markdown message, optional option buttons, '
+    + 'and optional file/diff links that the user can click. '
+    + 'For links, use "ref" alone to show one file; add "rightRef" only when the step should show a diff. '
+    + 'Single-step behavior: if the step has options, the tool waits for the user to pick one option and then completes the interaction; '
+    + 'if the step has no options, it is purely informational and is auto-completed by the tool '
+    + '(do not promise the user a "Finish" or "Next" button; there is none, and no comments can be entered). '
+    + 'Multi-step behavior: the user advances through steps with a "Next" button (or "Finish" on the last step), can revisit previous steps, '
     + 'and may add free-form comments on every step. '
     + 'The tool returns a JSON string with { "completed": boolean, "steps": [{ "title", "value"?, "comments"?, "skipped"? }] }. '
     + 'If the user cancels mid-interaction, the tool returns whatever has been collected so far with "completed": false. '
@@ -184,69 +193,56 @@ export class UserInteractionTool implements ToolProvider {
         };
     }
 
-    setStepResult(toolCallId: string, stepIndex: number, partial: Partial<UserInteractionStepResult>): void {
+    /**
+     * Resolve the pending interaction with the given final result. The renderer is the single
+     * source of truth for the collected user input and passes the full result here on Finish
+     * (or on a per-option click for single-step interactions).
+     */
+    completeInteraction(toolCallId: string, result: UserInteractionResult): void {
+        this.resolveInteraction(toolCallId, result);
+    }
+
+    /**
+     * Push the latest partial result so the tool can resolve with it on cancellation.
+     * The renderer should call this whenever the user changes step state. Calls for
+     * an already-resolved interaction are silently ignored.
+     */
+    recordPartial(toolCallId: string, partial: UserInteractionResult): void {
         const pending = this.pendingInteractions.get(toolCallId);
         if (!pending || pending.resolved) {
             return;
         }
-        if (stepIndex < 0 || stepIndex >= pending.steps.length) {
-            return;
-        }
-        const existing = pending.stepResults[stepIndex] ?? { title: pending.steps[stepIndex].title };
-        pending.stepResults[stepIndex] = {
-            ...existing,
-            ...partial,
-            title: pending.steps[stepIndex].title
-        };
+        pending.latestPartial = partial;
     }
 
-    completeInteraction(toolCallId: string): void {
+    protected resolveInteraction(toolCallId: string, result: UserInteractionResult): void {
         const pending = this.pendingInteractions.get(toolCallId);
         if (!pending || pending.resolved) {
             return;
         }
         pending.resolved = true;
-        const result: UserInteractionResult = {
-            completed: true,
-            steps: this.normalizeStepResults(pending)
-        };
         pending.deferred.resolve(JSON.stringify(result));
     }
 
-    /**
-     * Set the result for a step and immediately complete the interaction.
-     * Use this to atomically pass the user's input value into the result, avoiding
-     * any reliance on synchronous state updates between `setStepResult` and `completeInteraction`.
-     */
-    completeInteractionWith(toolCallId: string, stepIndex: number, partial: Partial<UserInteractionStepResult>): void {
-        this.setStepResult(toolCallId, stepIndex, partial);
-        this.completeInteraction(toolCallId);
-    }
-
-    cancelInteraction(toolCallId: string): void {
+    protected cancelPending(toolCallId: string): void {
         const pending = this.pendingInteractions.get(toolCallId);
         if (!pending || pending.resolved) {
             return;
         }
-        pending.resolved = true;
-        const steps = this.normalizeStepResults(pending);
-        // Mark steps without any user input as skipped.
-        for (let i = 0; i < steps.length; i++) {
-            const step = steps[i];
-            const hasInput = step.value !== undefined || (step.comments && step.comments.length > 0);
-            if (!hasInput) {
-                steps[i] = { ...step, skipped: true };
-            }
-        }
-        const result: UserInteractionResult = { completed: false, steps };
-        pending.deferred.resolve(JSON.stringify(result));
-    }
-
-    protected normalizeStepResults(pending: PendingInteraction): UserInteractionStepResult[] {
-        return pending.steps.map((step, i) => pending.stepResults[i] ?? { title: step.title });
+        const result = pending.latestPartial ?? {
+            completed: false,
+            steps: pending.steps.map(step => ({ title: step.title, skipped: true }))
+        };
+        this.resolveInteraction(toolCallId, result);
     }
 
     async openLink(link: UserInteractionLink): Promise<void> {
+        const normalizedLink = normalizeUserInteractionLink(link);
+        if (!normalizedLink) {
+            return;
+        }
+        link = normalizedLink;
+
         if (link.rightRef !== undefined) {
             const resolvedLeftUri = await this.resolveDiffSideUri(link.ref);
             const resolvedRightUri = await this.resolveDiffSideUri(link.rightRef);
@@ -300,8 +296,7 @@ export class UserInteractionTool implements ToolProvider {
         if (ref.gitRef) {
             const repo = this.scmService.findRepository(fileUri);
             if (repo) {
-                const query = { path: fileUri['codeUri'].fsPath, ref: ref.gitRef };
-                return fileUri.withScheme(repo.provider.id).withQuery(JSON.stringify(query));
+                return repo.toUriAtRef(fileUri, ref.gitRef);
             }
             console.warn(`No SCM repository found to resolve gitRef '${ref.gitRef}' for '${ref.path}'`);
             return undefined;
@@ -344,13 +339,12 @@ export class UserInteractionTool implements ToolProvider {
         const pending: PendingInteraction = {
             deferred: new Deferred<string>(),
             steps,
-            stepResults: new Array(steps.length),
             resolved: false
         };
         this.pendingInteractions.set(toolCallId, pending);
 
         const cancellationToken = ToolInvocationContext.getCancellationToken(ctx);
-        const cancellationListener = cancellationToken?.onCancellationRequested(() => this.cancelInteraction(toolCallId));
+        const cancellationListener = cancellationToken?.onCancellationRequested(() => this.cancelPending(toolCallId));
 
         try {
             return await pending.deferred.promise;