@theia/ai-ide 1.76.0-next.6 → 1.76.0

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

@@ -81,7 +81,9 @@ const UserInteractionComponent: React.FC<UserInteractionComponentProps> = ({
 }) => {
     const steps = args.interactions;
     const stepCount = steps.length;
-    const [currentStep, setCurrentStep] = React.useState(0);
+    // Resume at the step another mount of this interaction left off at (e.g. the collapsed
+    // delegation summary vs. the expanded details render independent components).
+    const [currentStep, setCurrentStep] = React.useState(() => tool.getCurrentStep(toolCallId) ?? 0);
     // The tool's result (partial or final) is the single source of truth for step states.
     const [stepStates, setStepStates] = React.useState<StepState[]>(() => {
         if (result) {
@@ -122,6 +124,13 @@ const UserInteractionComponent: React.FC<UserInteractionComponentProps> = ({
         }
     }, [currentStep, activeStep, isFinal, tool]);
 
+    // Keep the tool informed of the current step so that a later mount resumes here.
+    React.useEffect(() => {
+        if (!isFinal) {
+            tool.recordCurrentStep(toolCallId, currentStep);
+        }
+    }, [currentStep, isFinal, tool, toolCallId]);
+
     const buildResult = React.useCallback((completed: boolean, states: StepState[]): UserInteractionResult => ({
         completed,
         steps: steps.map((step, i) => {
@@ -494,8 +503,13 @@ const MalformedInteraction: React.FC<{ message: string }> = ({ message }) => (
     </div>
 );
 
-interface ToolErrorResult { error: string }
-function parseToolErrorResult(raw: unknown): ToolErrorResult | undefined {
+/**
+ * Extract the message to show for a tool result that the renderer cannot turn into an interaction.
+ * Covers both shapes the tool can produce for malformed arguments: the `{ error }` result of the
+ * handler, and the `{ denied: true, reason }` result of the auto-deny in `checkAutoAction`, which
+ * is what a validation failure produces before the handler ever runs.
+ */
+function extractErrorMessage(raw: unknown): string | undefined {
     let candidate: unknown = raw;
     if (typeof raw === 'string') {
         try {
@@ -504,8 +518,15 @@ function parseToolErrorResult(raw: unknown): ToolErrorResult | undefined {
             return undefined;
         }
     }
-    if (candidate && typeof candidate === 'object' && typeof (candidate as { error?: unknown }).error === 'string') {
-        return candidate as ToolErrorResult;
+    if (!candidate || typeof candidate !== 'object') {
+        return undefined;
+    }
+    const error = (candidate as { error?: unknown }).error;
+    if (typeof error === 'string') {
+        return error;
+    }
+    if (ToolCallChatResponseContent.isDenialResult(candidate) && typeof candidate.reason === 'string') {
+        return candidate.reason;
     }
     return undefined;
 }
@@ -553,8 +574,18 @@ export class UserInteractionToolRenderer implements ChatResponsePartRenderer<Too
         return -1;
     }
 
+    /**
+     * The regular rendering of this tool already is the interactive UI, so reuse it
+     * where only the pending interaction should be shown (e.g. on the collapsed
+     * summary of a delegated session, see #17952).
+     */
+    renderConfirmation(response: ToolCallChatResponseContent, parentNode: ResponseNode): ReactNode {
+        return this.render(response, parentNode);
+    }
+
     render(response: ToolCallChatResponseContent, parentNode: ResponseNode): ReactNode {
-        const args = parseUserInteractionArgs(response.arguments);
+        const validation = parseUserInteractionArgs(response.arguments);
+        const args = validation.ok ? validation.args : undefined;
 
         if (!args || !response.id) {
             // The tool already returned a result but the args don't validate: this
@@ -562,8 +593,7 @@ export class UserInteractionToolRenderer implements ChatResponsePartRenderer<Too
             // rejected, or arguments that fail shared parsing). Show an error state
             // instead of a perpetual loading spinner.
             if (response.result !== undefined) {
-                const error = parseToolErrorResult(response.result);
-                const message = error?.error
+                const message = extractErrorMessage(response.result)
                     ?? nls.localize('theia/ai-ide/userInteractionMalformedFallback', 'The arguments could not be parsed.');
                 return <MalformedInteraction message={message} />;
             }

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

@@ -119,13 +119,73 @@ describe('UserInteractionTool', () => {
     it('should return error when no interactions are provided', async () => {
         const handler = tool.getTool().handler;
         const result = await handler(JSON.stringify({ interactions: [] }), { toolCallId: 'x' });
-        expect(JSON.parse(result as string).error).to.equal('No interactions provided');
+        expect(JSON.parse(result as string).error).to.match(/at least one step/);
     });
 
     it('should return error when arguments are invalid JSON', async () => {
         const handler = tool.getTool().handler;
         const result = await handler('not-json', { toolCallId: 'x' });
-        expect(JSON.parse(result as string).error).to.equal('Invalid arguments');
+        expect(JSON.parse(result as string).error).to.match(/valid JSON/i);
+    });
+
+    it('should reject a single step whose options are malformed instead of auto-completing it', async () => {
+        const handler = tool.getTool().handler;
+        const args = JSON.stringify({
+            interactions: [{
+                title: 'Apply fix?',
+                message: 'Should I apply this change?',
+                options: '[{"text":"Yes","value":"yes"}]'
+            }]
+        });
+        const result = JSON.parse(await handler(args, { toolCallId: 'malformed-options' }) as string);
+        expect(result.error).to.match(/step 1: "options" must be an array/i);
+        expect(result.completed).to.be.undefined;
+    });
+
+    it('should reject a single step with a partially malformed options array instead of silently dropping the bad option', async () => {
+        const handler = tool.getTool().handler;
+        const args = JSON.stringify({
+            interactions: [{
+                title: 'Apply fix?',
+                message: 'Should I apply this change?',
+                options: [{ text: 'Approve', value: 'approve' }, { text: 'Reject', value: 'reject' }, { label: 'Defer', value: 'defer' }]
+            }]
+        });
+        const result = JSON.parse(await handler(args, { toolCallId: 'partial-options' }) as string);
+        expect(result.error).to.match(/step 1, option 3: "text" and "value" are required strings/i);
+        expect(result.completed).to.be.undefined;
+    });
+
+    it('should reject a JSON-encoded interactions string with an actionable message', async () => {
+        const handler = tool.getTool().handler;
+        const args = JSON.stringify({ interactions: '[{"title":"T","message":"M"}]' });
+        const result = JSON.parse(await handler(args, { toolCallId: 'encoded-interactions' }) as string);
+        expect(result.error).to.match(/"interactions" must be an array of step objects, received string/);
+        expect(result.error).to.match(/do not JSON-encode nested values/i);
+    });
+
+    it('should auto-complete a single step that genuinely has no options', async () => {
+        const handler = tool.getTool().handler;
+        const args = JSON.stringify({ interactions: [{ title: 'FYI', message: 'Heads up' }] });
+        const result = parseResult(await handler(args, { toolCallId: 'informational' }));
+        expect(result.completed).to.be.true;
+        expect(result.steps).to.deep.equal([{ title: 'FYI' }]);
+    });
+
+    describe('checkAutoAction', () => {
+
+        it('should auto-deny malformed arguments so the model receives the validation error', () => {
+            const args = JSON.stringify({
+                interactions: [{ title: 'Apply fix?', message: 'Confirm?', options: '[{"text":"Yes","value":"yes"}]' }]
+            });
+            const autoAction = tool.getTool().checkAutoAction!(args);
+            expect(autoAction?.action).to.equal('deny');
+            expect(autoAction?.reason).to.match(/step 1: "options" must be an array/i);
+        });
+
+        it('should not auto-deny well-formed arguments, leaving confirmation to the user', () => {
+            expect(tool.getTool().checkAutoAction!(singleStepArgs())).to.be.undefined;
+        });
     });
 
     it('should return error when no tool call ID is available', async () => {
@@ -134,6 +194,145 @@ describe('UserInteractionTool', () => {
         expect(JSON.parse(result as string).error).to.equal('No tool call ID available');
     });
 
+    describe('chat context surfacing', () => {
+        interface MockChatCtx {
+            ctx: object;
+            response: {
+                response: { content: object[] };
+                fireInteractionNeeded: sinon.SinonSpy;
+                waitForInput: sinon.SinonSpy;
+                stopWaitingForInput: sinon.SinonSpy;
+            };
+            contentPart: {
+                kind: string;
+                id: string;
+                requestUserInput: sinon.SinonSpy;
+                userInputHandled: sinon.SinonSpy;
+            };
+        }
+
+        // Mimics the shape of ChatToolContext with a mock response model, so we can
+        // assert the tool announces its pending interaction (issue #17952: interactions
+        // inside delegated sessions were never surfaced because the tool never fired
+        // interactionNeeded).
+        const createChatCtx = (toolCallId: string, withContentPart = true): MockChatCtx => {
+            const contentPart = {
+                kind: 'toolCall',
+                id: toolCallId,
+                requestUserInput: sinon.spy(),
+                userInputHandled: sinon.spy()
+            };
+            const response = {
+                response: { content: withContentPart ? [contentPart] : [] },
+                fireInteractionNeeded: sinon.spy(),
+                waitForInput: sinon.spy(),
+                stopWaitingForInput: sinon.spy()
+            };
+            return { ctx: { toolCallId, request: {}, response }, response, contentPart };
+        };
+
+        it('should fire interactionNeeded with the tool call content part while waiting', async () => {
+            const handler = tool.getTool().handler;
+            const { ctx, response, contentPart } = createChatCtx('call-fire');
+
+            const handlerPromise = handler(singleStepArgs(), ctx);
+
+            expect(response.fireInteractionNeeded.calledOnce).to.be.true;
+            expect(response.fireInteractionNeeded.firstCall.args[0]).to.equal(contentPart);
+            expect(response.waitForInput.calledOnce).to.be.true;
+
+            tool.completeInteraction('call-fire', { completed: true, steps: [{ title: 'Choose', value: 'a' }] });
+            await handlerPromise;
+        });
+
+        it('should mark the content part as awaiting user input while blocked and clear it afterwards', async () => {
+            const handler = tool.getTool().handler;
+            const { ctx, contentPart } = createChatCtx('call-mark');
+
+            const handlerPromise = handler(singleStepArgs(), ctx);
+
+            expect(contentPart.requestUserInput.calledOnce).to.be.true;
+            expect(contentPart.userInputHandled.called).to.be.false;
+
+            tool.completeInteraction('call-mark', { completed: true, steps: [{ title: 'Choose', value: 'a' }] });
+            await handlerPromise;
+
+            expect(contentPart.userInputHandled.calledOnce).to.be.true;
+        });
+
+        it('should not fire interactionNeeded when no matching tool call content exists', async () => {
+            const handler = tool.getTool().handler;
+            const { ctx, response } = createChatCtx('call-missing', false);
+
+            const handlerPromise = handler(singleStepArgs(), ctx);
+
+            expect(response.fireInteractionNeeded.called).to.be.false;
+            // Waiting state must still be surfaced even without a content part.
+            expect(response.waitForInput.calledOnce).to.be.true;
+
+            tool.completeInteraction('call-missing', { completed: true, steps: [{ title: 'Choose', value: 'a' }] });
+            await handlerPromise;
+        });
+
+        it('should not fire interactionNeeded for informational single-step interactions', async () => {
+            const handler = tool.getTool().handler;
+            const { ctx, response } = createChatCtx('call-info');
+
+            const result = parseResult(await handler(
+                JSON.stringify({ interactions: [{ title: 'FYI', message: 'Just info' }] }), ctx
+            ));
+
+            expect(result.completed).to.be.true;
+            expect(response.fireInteractionNeeded.called).to.be.false;
+            expect(response.waitForInput.called).to.be.false;
+        });
+    });
+
+    describe('current step across renderer mounts', () => {
+        // The wizard can be mounted twice for one interaction (collapsed delegation summary
+        // and expanded details). The tool keeps the current step so a new mount resumes
+        // where the previous one left off instead of restarting at step 0.
+        const multiStepArgs = (): string => JSON.stringify({
+            interactions: [
+                { title: 'One', message: 'first' },
+                { title: 'Two', message: 'second', options: [{ text: 'OK', value: 'ok' }] },
+                { title: 'Three', message: 'third' }
+            ]
+        });
+        const completedResult = (): UserInteractionResult => ({
+            completed: true,
+            steps: [{ title: 'One' }, { title: 'Two', value: 'ok' }, { title: 'Three' }]
+        });
+
+        it('should return undefined when no interaction is pending', () => {
+            expect(tool.getCurrentStep('unknown')).to.be.undefined;
+        });
+
+        it('should remember the recorded step while the interaction is pending', async () => {
+            const handler = tool.getTool().handler;
+            const handlerPromise = handler(multiStepArgs(), { toolCallId: 'call-step' });
+
+            tool.recordCurrentStep('call-step', 2);
+            expect(tool.getCurrentStep('call-step')).to.equal(2);
+
+            tool.completeInteraction('call-step', completedResult());
+            await handlerPromise;
+        });
+
+        it('should forget the step once the interaction resolved', async () => {
+            const handler = tool.getTool().handler;
+            const handlerPromise = handler(multiStepArgs(), { toolCallId: 'call-step-done' });
+            tool.recordCurrentStep('call-step-done', 1);
+
+            tool.completeInteraction('call-step-done', completedResult());
+            await handlerPromise;
+
+            expect(tool.getCurrentStep('call-step-done')).to.be.undefined;
+            tool.recordCurrentStep('call-step-done', 2);
+            expect(tool.getCurrentStep('call-step-done')).to.be.undefined;
+        });
+    });
+
     it('should resolve the handler with the result passed to completeInteraction', async () => {
         const handler = tool.getTool().handler;
         const handlerPromise = handler(singleStepArgs(), { toolCallId: 'call-1' });

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

@@ -15,8 +15,8 @@
 // *****************************************************************************
 
 import { ToolProvider, ToolRequest, ToolRequestParameterProperty, ToolRequestParameters } from '@theia/ai-core';
-import { ToolInvocationContext } from '@theia/ai-core/lib/common/language-model';
-import { ChatToolContext } from '@theia/ai-chat';
+import { AutoActionResult, ToolInvocationContext } from '@theia/ai-core/lib/common/language-model';
+import { ChatToolContext, ToolCallChatResponseContent } from '@theia/ai-chat';
 import { DiffUris } from '@theia/core/lib/browser/diff-uris';
 import { open, OpenerService } from '@theia/core/lib/browser';
 import { Deferred } from '@theia/core/lib/common/promise-util';
@@ -51,6 +51,13 @@ interface PendingInteraction {
      * is canceled. If absent (no renderer mounted) the tool resolves with all steps skipped.
      */
     latestPartial?: UserInteractionResult;
+    /**
+     * Step the user is currently viewing, pushed by the renderer via
+     * {@link UserInteractionTool.recordCurrentStep}. Lets another mount of the same
+     * interaction (e.g. the collapsed delegation summary and the expanded details)
+     * resume at that step instead of restarting at the first one.
+     */
+    currentStep?: number;
 }
 
 // Schemas are module-level constants so they are built once at load time
@@ -103,8 +110,9 @@ const STEP_SCHEMA: ToolRequestParameterProperty = {
                 },
                 required: ['text', 'value']
             },
-            description: 'Optional buttons offered to the user for this step. Omit for purely informational steps; '
-                + 'a hardcoded "Next"/"Finish" button is always shown to advance.'
+            description: 'Buttons offered to the user for this step. '
+                + 'Omit it (or pass an empty array) only for purely informational steps: a step without options is never a confirmation, '
+                + 'so never use one to ask for approval. In a multi-step interaction a hardcoded "Next"/"Finish" button is always shown to advance.'
         },
         links: {
             type: 'array',
@@ -161,7 +169,8 @@ const TOOL_DESCRIPTION = 'Present an interactive user interaction. Each step has
     + '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. '
     + 'Use this to walk users through a series of pre-determined findings or decisions in a single tool call, '
-    + 'or to surface a single message/diff that should be shown inline in the chat.';
+    + 'or to surface a single message/diff that should be shown inline in the chat. '
+    + 'Pass nested values as real JSON arrays and objects, never as JSON-encoded strings.';
 
 @injectable()
 export class UserInteractionTool implements ToolProvider {
@@ -194,10 +203,22 @@ export class UserInteractionTool implements ToolProvider {
             providerName: 'ai-ide',
             description: TOOL_DESCRIPTION,
             parameters: TOOL_PARAMETERS,
-            handler: (argString: string, ctx) => this.handleInteraction(argString, ctx)
+            handler: (argString: string, ctx) => this.handleInteraction(argString, ctx),
+            checkAutoAction: (argString: string) => this.checkArguments(argString)
         };
     }
 
+    /**
+     * Auto-deny invocations whose arguments do not validate, handing the validation error back to
+     * the model. Without this the confirmation flow would stall: the renderer refuses to mount the
+     * interaction (and with it the Allow/Deny buttons) for arguments it cannot render, so a
+     * confirmation that nobody can give would be awaited indefinitely.
+     */
+    protected checkArguments(argString: string): AutoActionResult | undefined {
+        const validation = parseUserInteractionArgs(argString);
+        return validation.ok ? undefined : { action: 'deny', reason: validation.error };
+    }
+
     /**
      * 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
@@ -220,6 +241,25 @@ export class UserInteractionTool implements ToolProvider {
         pending.latestPartial = partial;
     }
 
+    /**
+     * Remember the step the user is currently viewing so another mount of the same
+     * interaction resumes there. Calls for an unknown or already-resolved interaction
+     * are silently ignored.
+     */
+    recordCurrentStep(toolCallId: string, step: number): void {
+        const pending = this.pendingInteractions.get(toolCallId);
+        if (!pending || pending.resolved) {
+            return;
+        }
+        pending.currentStep = step;
+    }
+
+    /** The step last recorded via {@link recordCurrentStep}, or undefined if nothing is pending. */
+    getCurrentStep(toolCallId: string): number | undefined {
+        const pending = this.pendingInteractions.get(toolCallId);
+        return pending && !pending.resolved ? pending.currentStep : undefined;
+    }
+
     protected resolveInteraction(toolCallId: string, result: UserInteractionResult): void {
         const pending = this.pendingInteractions.get(toolCallId);
         if (!pending || pending.resolved) {
@@ -310,18 +350,14 @@ export class UserInteractionTool implements ToolProvider {
     }
 
     protected async handleInteraction(argString: string, ctx: ToolInvocationContext | undefined): Promise<string> {
-        try {
-            JSON.parse(argString);
-        } catch {
-            return JSON.stringify({ error: 'Invalid arguments' });
-        }
         // Validate via the shared parser so the tool only ever waits for steps that
-        // the renderer would actually render. Otherwise the agent could send a
-        // step the UI filters out, leaving the tool blocked on input forever.
-        const validated = parseUserInteractionArgs(argString);
-        if (!validated || validated.interactions.length === 0) {
-            return JSON.stringify({ error: 'No interactions provided' });
+        // the renderer would actually render, and so that anything the agent got
+        // wrong is reported back to it verbatim instead of being silently dropped.
+        const validation = parseUserInteractionArgs(argString);
+        if (!validation.ok) {
+            return JSON.stringify({ error: validation.error });
         }
+        const validated = validation.args;
 
         const toolCallId = ToolInvocationContext.getToolCallId(ctx);
         if (!toolCallId) {
@@ -353,12 +389,27 @@ export class UserInteractionTool implements ToolProvider {
 
         // Mark the response as waiting for input while the interaction is pending, so it is
         // surfaced consistently with agent questions and tool confirmations (e.g. in the
-        // session overview and notifications).
+        // session overview and notifications). Announce the interaction via
+        // interactionNeeded so UIs that track pending interactions (e.g. the collapsed
+        // delegation summary) surface it like tool confirmations (#17952).
         const response = ChatToolContext.is(ctx) ? ctx.response : undefined;
-        response?.waitForInput();
+        let contentPart: ToolCallChatResponseContent | undefined;
+        if (response) {
+            contentPart = response.response.content.findLast(
+                (part): part is ToolCallChatResponseContent => ToolCallChatResponseContent.is(part) && part.id === toolCallId
+            );
+            if (contentPart) {
+                contentPart.requestUserInput();
+                response.fireInteractionNeeded(contentPart);
+            } else {
+                this.logger.warn(`No tool call content found for '${toolCallId}'; the pending interaction cannot be announced to interaction trackers.`);
+            }
+            response.waitForInput();
+        }
         try {
             return await pending.deferred.promise;
         } finally {
+            contentPart?.userInputHandled();
             response?.stopWaitingForInput();
             cancellationListener?.dispose();
             this.pendingInteractions.delete(toolCallId);

package/src/common/command-prompt-template.ts

@@ -51,7 +51,7 @@ when the user want to pass arguments to the command.
 {
     "type": "theia-command",
     "commandId": "preferences:open",
-    "arguments": ["ai-features"]
+    "arguments": ["editor.fontSize"]
 }
 \`\`\`