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

package/src/browser/commit-message-agent.spec.ts

@@ -0,0 +1,97 @@
+// *****************************************************************************
+// Copyright (C) 2026 EclipseSource GmbH.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { expect } from 'chai';
+import * as sinon from 'sinon';
+import { Container } from '@theia/core/shared/inversify';
+import { LanguageModel, LanguageModelRegistry, LanguageModelService, PromptService, UserRequest } from '@theia/ai-core';
+import { CommitMessageAgent } from './commit-message-agent';
+import { COMMIT_MESSAGE_SYSTEM_PROMPT_ID, COMMIT_MESSAGE_USER_PROMPT_ID } from './commit-message-prompt-template';
+
+describe('CommitMessageAgent', () => {
+
+    let container: Container;
+    let agent: CommitMessageAgent;
+    let registry: { selectLanguageModel: sinon.SinonStub };
+    let promptService: { getResolvedPromptFragmentWithoutFunctions: sinon.SinonStub; getPromptVariantInfo: sinon.SinonStub };
+    let languageModelService: { sendRequest: sinon.SinonStub };
+    const fakeModel = {} as LanguageModel;
+
+    beforeEach(() => {
+        container = new Container();
+        registry = { selectLanguageModel: sinon.stub().resolves(fakeModel) };
+        promptService = {
+            getResolvedPromptFragmentWithoutFunctions: sinon.stub().callsFake((id: string) => Promise.resolve({ text: `resolved:${id}` })),
+            getPromptVariantInfo: sinon.stub().returns(undefined)
+        };
+        languageModelService = { sendRequest: sinon.stub().resolves({ text: 'feat: add thing\n' }) };
+
+        container.bind(LanguageModelRegistry).toConstantValue(registry as unknown as LanguageModelRegistry);
+        container.bind(PromptService).toConstantValue(promptService as unknown as PromptService);
+        container.bind(LanguageModelService).toConstantValue(languageModelService as unknown as LanguageModelService);
+        container.bind(CommitMessageAgent).toSelf();
+
+        agent = container.get(CommitMessageAgent);
+    });
+
+    afterEach(() => sinon.restore());
+
+    it('is a plain agent that exposes no functions', () => {
+        expect(agent.functions).to.be.empty;
+    });
+
+    it('resolves both prompts, sends the request and returns the trimmed message', async () => {
+        const result = await agent.generateCommitMessage('the diff');
+
+        expect(result).to.equal('feat: add thing');
+        expect(promptService.getResolvedPromptFragmentWithoutFunctions.calledWith(COMMIT_MESSAGE_SYSTEM_PROMPT_ID)).to.be.true;
+        expect(promptService.getResolvedPromptFragmentWithoutFunctions.calledWith(COMMIT_MESSAGE_USER_PROMPT_ID)).to.be.true;
+        expect(languageModelService.sendRequest.calledOnce).to.be.true;
+    });
+
+    it('injects the diff into the prompt parameters', async () => {
+        await agent.generateCommitMessage('the diff');
+
+        const [, params] = promptService.getResolvedPromptFragmentWithoutFunctions.firstCall.args;
+        expect(params).to.deep.equal({ changes: 'the diff' });
+    });
+
+    it('sends a system and a user message tagged with the agent id and the cancellation token', async () => {
+        const token = { isCancellationRequested: false } as unknown as UserRequest['cancellationToken'];
+        await agent.generateCommitMessage('the diff', token);
+
+        const request = languageModelService.sendRequest.firstCall.args[1] as UserRequest;
+        expect(request.agentId).to.equal(agent.id);
+        expect(request.cancellationToken).to.equal(token);
+        expect(request.messages.map(m => m.actor)).to.deep.equal(['system', 'user']);
+    });
+
+    it('throws when no language model is available', async () => {
+        registry.selectLanguageModel.resolves(undefined);
+
+        const error = await agent.generateCommitMessage('the diff').then(() => undefined, e => e);
+        expect(error).to.be.instanceOf(Error);
+        expect((error as Error).message).to.match(/No language model/);
+    });
+
+    it('throws when the prompts cannot be resolved', async () => {
+        promptService.getResolvedPromptFragmentWithoutFunctions.resolves(undefined);
+
+        const error = await agent.generateCommitMessage('the diff').then(() => undefined, e => e);
+        expect(error).to.be.instanceOf(Error);
+        expect((error as Error).message).to.match(/prompt service/);
+    });
+});

package/src/browser/commit-message-agent.ts

@@ -0,0 +1,113 @@
+// *****************************************************************************
+// Copyright (C) 2026 EclipseSource GmbH.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import {
+    Agent,
+    getTextOfResponse,
+    LanguageModelRegistry,
+    LanguageModelRequirement,
+    LanguageModelService,
+    PromptService,
+    UserRequest
+} from '@theia/ai-core';
+import { generateUuid, nls } from '@theia/core';
+import { CancellationToken } from '@theia/core/lib/common/cancellation';
+import { inject, injectable } from '@theia/core/shared/inversify';
+import { commitMessagePrompts, COMMIT_MESSAGE_SYSTEM_PROMPT_ID, COMMIT_MESSAGE_USER_PROMPT_ID } from './commit-message-prompt-template';
+
+export const COMMIT_MESSAGE_AGENT_ID = 'Commit Message';
+
+@injectable()
+export class CommitMessageAgent implements Agent {
+
+    id = COMMIT_MESSAGE_AGENT_ID;
+    name = COMMIT_MESSAGE_AGENT_ID;
+
+    description = nls.localize('theia/ai-ide/commitMessageAgent/description',
+        'Generates git commit messages from the staged changes in the workspace repository. ' +
+        'Invoked from the SCM commit-message input via the AI sparkle button.');
+
+    variables = [];
+    functions = [];
+
+    prompts = commitMessagePrompts;
+
+    languageModelRequirements: LanguageModelRequirement[] = [{
+        purpose: 'commit-message',
+        identifier: 'default/universal',
+    }];
+
+    agentSpecificVariables = [
+        {
+            name: 'changes',
+            usedInPrompt: true,
+            description: nls.localize(
+                'theia/ai-ide/commitMessageAgent/vars/changes/description',
+                'The unified git diff of the staged changes the commit message is generated from.'
+            )
+        }
+    ];
+
+    @inject(LanguageModelRegistry)
+    protected readonly languageModelRegistry: LanguageModelRegistry;
+
+    @inject(PromptService)
+    protected readonly promptService: PromptService;
+
+    @inject(LanguageModelService)
+    protected readonly languageModelService: LanguageModelService;
+
+    /**
+     * Generates a commit message from the given unified diff. Returns the trimmed message text.
+     *
+     * @throws if no language model is available or the prompts cannot be resolved.
+     */
+    async generateCommitMessage(changes: string, cancellationToken?: CancellationToken): Promise<string> {
+        const lm = await this.languageModelRegistry.selectLanguageModel({
+            agent: this.id,
+            ...this.languageModelRequirements[0]
+        });
+        if (!lm) {
+            throw new Error('No language model available for the Commit Message agent.');
+        }
+
+        const parameters = { changes };
+        const systemMessage = await this.promptService.getResolvedPromptFragmentWithoutFunctions(COMMIT_MESSAGE_SYSTEM_PROMPT_ID, parameters).then(p => p?.text);
+        const userMessage = await this.promptService.getResolvedPromptFragmentWithoutFunctions(COMMIT_MESSAGE_USER_PROMPT_ID, parameters).then(p => p?.text);
+        if (!systemMessage || !userMessage) {
+            throw new Error('The prompt service did not return prompts for the Commit Message agent.');
+        }
+
+        const variantInfo = this.promptService.getPromptVariantInfo(COMMIT_MESSAGE_SYSTEM_PROMPT_ID);
+
+        const request: UserRequest = {
+            messages: [
+                { actor: 'system', type: 'text', text: systemMessage },
+                { actor: 'user', type: 'text', text: userMessage }
+            ],
+            agentId: this.id,
+            sessionId: generateUuid(),
+            requestId: generateUuid(),
+            cancellationToken,
+            promptVariantId: variantInfo?.variantId,
+            isPromptVariantCustomized: variantInfo?.isCustomized
+        };
+
+        const result = await this.languageModelService.sendRequest(lm, request);
+        const text = await getTextOfResponse(result);
+        return text.trim();
+    }
+}

package/src/browser/commit-message-command-contribution.ts

@@ -0,0 +1,67 @@
+// *****************************************************************************
+// Copyright (C) 2026 EclipseSource GmbH.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { CommandContribution, CommandRegistry } from '@theia/core';
+import { inject, injectable } from '@theia/core/shared/inversify';
+import { AgentService } from '@theia/ai-core/lib/common';
+import { AICommandHandlerFactory } from '@theia/ai-core/lib/browser';
+import { ScmService } from '@theia/scm/lib/browser/scm-service';
+import { COMMIT_MESSAGE_AGENT_ID } from './commit-message-agent';
+import { CommitMessageCommands } from './commit-message-commands';
+import { CommitMessageRunner } from './commit-message-runner';
+
+@injectable()
+export class CommitMessageCommandContribution implements CommandContribution {
+
+    @inject(CommitMessageRunner)
+    protected readonly runner: CommitMessageRunner;
+
+    @inject(ScmService)
+    protected readonly scmService: ScmService;
+
+    @inject(AgentService)
+    protected readonly agentService: AgentService;
+
+    @inject(AICommandHandlerFactory)
+    protected readonly commandHandlerFactory: AICommandHandlerFactory;
+
+    registerCommands(registry: CommandRegistry): void {
+        registry.registerCommand(CommitMessageCommands.GENERATE_FROM_STAGED, this.commandHandlerFactory({
+            execute: () => this.execute(),
+            isEnabled: () => this.isEnabled()
+        }));
+    }
+
+    protected execute(): void | Promise<void> {
+        if (this.runner.isRunning()) {
+            this.runner.cancel();
+            return;
+        }
+        return this.runner.run();
+    }
+
+    protected isEnabled(): boolean {
+        // While a generation is in flight the command cancels it, which must stay possible even
+        // once the git extension has disabled the commit input for an ongoing commit.
+        if (this.runner.isRunning()) {
+            return true;
+        }
+        const repository = this.scmService.selectedRepository;
+        return !!repository
+            && repository.input.enabled
+            && this.agentService.isEnabled(COMMIT_MESSAGE_AGENT_ID);
+    }
+}

package/src/browser/commit-message-commands.ts

@@ -0,0 +1,25 @@
+// *****************************************************************************
+// Copyright (C) 2026 EclipseSource GmbH.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { Command } from '@theia/core';
+
+export namespace CommitMessageCommands {
+    export const GENERATE_FROM_STAGED: Command = Command.toLocalizedCommand({
+        id: 'ai-ide.commit-message.generate-from-staged',
+        category: 'AI',
+        label: 'Generate Commit Message from Staged Changes'
+    }, 'theia/ai-ide/commit-message/generate-from-staged');
+}

package/src/browser/commit-message-prompt-template.ts

@@ -0,0 +1,65 @@
+// *****************************************************************************
+// Copyright (C) 2026 EclipseSource GmbH.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-only WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { BasePromptFragment } from '@theia/ai-core/lib/common';
+
+export const COMMIT_MESSAGE_SYSTEM_PROMPT_ID = 'commit-message-system';
+export const COMMIT_MESSAGE_USER_PROMPT_ID = 'commit-message-user';
+
+export const commitMessageSystemPrompt: BasePromptFragment = {
+    id: COMMIT_MESSAGE_SYSTEM_PROMPT_ID,
+    template: `# Role
+
+You are an assistant that produces **git commit messages** from a unified diff of changes in a
+workspace's git repository. The diff is provided to you directly in the user message.
+
+# Output Format
+
+Return ONLY the commit message text. Nothing else.
+
+- **No** markdown headings, no quotes, no code fences, no preamble like "Here is …".
+- First line is the **subject**:
+  - imperative mood ("Add", "Fix", "Refactor", not "Added"/"Adds")
+  - prefer the **Conventional Commits** style where appropriate, e.g. \`feat:\`, \`fix:\`, \`refactor:\`, \`docs:\`, \`test:\`, \`chore:\`, \`build:\`, \`ci:\`, \`perf:\`
+  - at most 72 characters
+  - no trailing period
+- If a body is needed to explain the *why* or non-obvious *what*, separate it from the subject with a single blank line.
+  Wrap body lines at ~72 characters. Use bullet lists (\`- …\`) for multiple changes.
+- Keep the message concise. Do not invent context that is not visible in the diff.
+
+# Constraints
+
+- Base the message only on the provided diff. Never include the diff itself in the response.
+- Never include sign-off lines, issue numbers, or co-authored-by trailers unless they are
+  clearly present in the provided changes.
+- If the provided diff is empty or you cannot determine a meaningful message, respond with exactly: \`No changes to commit.\`
+`
+};
+
+export const commitMessageUserPrompt: BasePromptFragment = {
+    id: COMMIT_MESSAGE_USER_PROMPT_ID,
+    template: `Generate a commit message for the following staged changes.
+
+\`\`\`diff
+{{changes}}
+\`\`\`
+`
+};
+
+export const commitMessagePrompts = [
+    { id: COMMIT_MESSAGE_SYSTEM_PROMPT_ID, defaultVariant: commitMessageSystemPrompt, variants: [] },
+    { id: COMMIT_MESSAGE_USER_PROMPT_ID, defaultVariant: commitMessageUserPrompt, variants: [] }
+];

package/src/browser/commit-message-runner.spec.ts

@@ -0,0 +1,266 @@
+// *****************************************************************************
+// Copyright (C) 2026 EclipseSource GmbH.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// 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';
+import { CancellationToken, ILogger, MessageService } from '@theia/core';
+import { ConfirmDialog } from '@theia/core/lib/browser/dialogs';
+import { ScmService } from '@theia/scm/lib/browser/scm-service';
+import { ScmInput } from '@theia/scm/lib/browser/scm-input';
+import { CommitMessageAgent } from './commit-message-agent';
+import { CommitMessageRunner } from './commit-message-runner';
+import { GetGitChangesTool } from './git-changes-tool';
+
+disableJSDOM();
+
+interface MockRepository {
+    input: ScmInput;
+    provider: { rootUri: string };
+}
+
+describe('CommitMessageRunner', () => {
+
+    let container: Container;
+    let runner: CommitMessageRunner;
+    let agent: { generateCommitMessage: sinon.SinonStub };
+    let gitChangesTool: { getStagedChanges: sinon.SinonStub };
+    let scmService: { selectedRepository: MockRepository | undefined };
+    let messageService: { warn: sinon.SinonStub; error: sinon.SinonStub; info: sinon.SinonStub };
+    let logger: { error: sinon.SinonStub; warn: sinon.SinonStub; info: sinon.SinonStub; debug: sinon.SinonStub; trace: sinon.SinonStub };
+    let repository: MockRepository;
+    let focusSpy: sinon.SinonSpy;
+    let confirmDialogOpen: sinon.SinonStub;
+
+    before(() => {
+        disableJSDOM = enableJSDOM();
+    });
+
+    after(() => {
+        disableJSDOM();
+    });
+
+    beforeEach(() => {
+        container = new Container();
+
+        const input = new ScmInput();
+        focusSpy = sinon.spy(input, 'focus');
+        repository = { input, provider: { rootUri: 'file:///workspace-root' } };
+
+        scmService = { selectedRepository: repository };
+        agent = { generateCommitMessage: sinon.stub().resolves('feat: add new thing') };
+        gitChangesTool = { getStagedChanges: sinon.stub().resolves('diff --git a b') };
+        messageService = {
+            warn: sinon.stub().resolves(undefined),
+            error: sinon.stub().resolves(undefined),
+            info: sinon.stub().resolves(undefined)
+        };
+        logger = {
+            error: sinon.stub(),
+            warn: sinon.stub(),
+            info: sinon.stub(),
+            debug: sinon.stub(),
+            trace: sinon.stub()
+        };
+        // The overwrite prompt is a modal `ConfirmDialog`, not a toast, so it is stubbed at the
+        // prototype instead of via `MessageService`.
+        confirmDialogOpen = sinon.stub(ConfirmDialog.prototype, 'open').resolves(true);
+
+        container.bind(CommitMessageAgent).toConstantValue(agent as unknown as CommitMessageAgent);
+        container.bind(GetGitChangesTool).toConstantValue(gitChangesTool as unknown as GetGitChangesTool);
+        container.bind(ScmService).toConstantValue(scmService as unknown as ScmService);
+        container.bind(MessageService).toConstantValue(messageService as unknown as MessageService);
+        container.bind(ILogger).toConstantValue(logger as unknown as ILogger);
+        container.bind(CommitMessageRunner).toSelf();
+
+        runner = container.get(CommitMessageRunner);
+    });
+
+    afterEach(() => sinon.restore());
+
+    it('writes the generated message into the SCM input and focuses it on success', async () => {
+        await runner.run();
+
+        expect(gitChangesTool.getStagedChanges.calledOnce).to.be.true;
+        // The diff is read for the selected repository, bypassing the model-facing tool call.
+        expect(gitChangesTool.getStagedChanges.firstCall.args[0]).to.equal(repository);
+        expect(agent.generateCommitMessage.calledOnce).to.be.true;
+        expect(repository.input.value).to.equal('feat: add new thing');
+        expect(focusSpy.calledOnce).to.be.true;
+        expect(messageService.error.called).to.be.false;
+    });
+
+    it('warns and does not invoke the agent when no repository is selected', async () => {
+        scmService.selectedRepository = undefined;
+
+        await runner.run();
+
+        expect(messageService.warn.calledOnce).to.be.true;
+        expect(gitChangesTool.getStagedChanges.called).to.be.false;
+        expect(agent.generateCommitMessage.called).to.be.false;
+    });
+
+    it('does not await notifications, so a dismissed toast cannot leave the run hanging', async () => {
+        scmService.selectedRepository = undefined;
+        // A toast the user never interacts with never settles; awaiting it would hang `run`.
+        messageService.warn.returns(new Promise<undefined>(() => { /* never settles */ }));
+
+        await runner.run();
+
+        expect(runner.isRunning()).to.be.false;
+    });
+
+    it('warns and does not invoke the agent when there are no staged changes', async () => {
+        gitChangesTool.getStagedChanges.resolves('   \n  ');
+
+        await runner.run();
+
+        expect(messageService.warn.calledOnce).to.be.true;
+        expect(agent.generateCommitMessage.called).to.be.false;
+        expect(repository.input.value).to.equal('');
+    });
+
+    it('skips the overwrite prompt when the commit field is empty', async () => {
+        repository.input.value = '';
+
+        await runner.run();
+
+        expect(confirmDialogOpen.called).to.be.false;
+        expect(repository.input.value).to.equal('feat: add new thing');
+    });
+
+    it('asks for confirmation in a modal dialog and overwrites when the user accepts', async () => {
+        repository.input.value = 'existing text';
+
+        await runner.run();
+
+        expect(confirmDialogOpen.calledOnce).to.be.true;
+        expect(repository.input.value).to.equal('feat: add new thing');
+    });
+
+    it('aborts without invoking the agent when the user cancels the overwrite prompt', async () => {
+        repository.input.value = 'existing text';
+        confirmDialogOpen.resolves(undefined);
+
+        await runner.run();
+
+        expect(agent.generateCommitMessage.called).to.be.false;
+        expect(repository.input.value).to.equal('existing text');
+    });
+
+    it('does not invoke the agent when the run is canceled while the overwrite prompt is open', async () => {
+        repository.input.value = 'existing text';
+        let confirm: (replace: boolean) => void = () => { /* set below */ };
+        confirmDialogOpen.callsFake(() => new Promise<boolean>(resolve => { confirm = resolve; }));
+
+        const runPromise = runner.run();
+        await new Promise(resolve => setTimeout(resolve, 0));
+
+        runner.cancel();
+        confirm(true);
+        await runPromise;
+
+        expect(agent.generateCommitMessage.called).to.be.false;
+        expect(repository.input.value).to.equal('existing text');
+    });
+
+    it('shows an error notification when the agent fails', async () => {
+        agent.generateCommitMessage.rejects(new Error('boom'));
+
+        await runner.run();
+
+        expect(messageService.error.calledOnce).to.be.true;
+        expect(messageService.error.firstCall.args[0]).to.contain('boom');
+        expect(repository.input.value).to.equal('');
+    });
+
+    it('shows an error notification when reading the staged changes fails', async () => {
+        gitChangesTool.getStagedChanges.rejects(new Error('fatal: not a git repository'));
+
+        await runner.run();
+
+        expect(messageService.error.calledOnce).to.be.true;
+        expect(messageService.error.firstCall.args[0]).to.contain('fatal: not a git repository');
+        expect(agent.generateCommitMessage.called).to.be.false;
+    });
+
+    it('warns when the model returns an empty message', async () => {
+        agent.generateCommitMessage.resolves('');
+
+        await runner.run();
+
+        expect(messageService.warn.calledOnce).to.be.true;
+        expect(repository.input.value).to.equal('');
+    });
+
+    it('does not change the input or notify when the run is canceled mid-generation', async () => {
+        let resolveGeneration: (message: string) => void = () => { /* set below */ };
+        agent.generateCommitMessage.callsFake(() => new Promise<string>(resolve => { resolveGeneration = resolve; }));
+
+        const runPromise = runner.run();
+        await new Promise(resolve => setTimeout(resolve, 0));
+        expect(runner.isRunning()).to.be.true;
+
+        runner.cancel();
+        resolveGeneration('feat: ignored');
+        await runPromise;
+
+        expect(repository.input.value).to.equal('');
+        expect(messageService.error.called).to.be.false;
+        expect(runner.isRunning()).to.be.false;
+    });
+
+    it('ignores a second run while one is still in flight', async () => {
+        let resolveChanges: (diff: string) => void = () => { /* set below */ };
+        gitChangesTool.getStagedChanges.callsFake(() => new Promise<string>(resolve => { resolveChanges = resolve; }));
+
+        const firstRun = runner.run();
+        await new Promise(resolve => setTimeout(resolve, 0));
+        expect(runner.isRunning()).to.be.true;
+
+        await runner.run();
+        expect(gitChangesTool.getStagedChanges.calledOnce).to.be.true;
+
+        resolveChanges('diff --git a b');
+        await firstRun;
+        expect(runner.isRunning()).to.be.false;
+    });
+
+    it('passes its cancellation token down so the git command can be aborted', async () => {
+        let capturedToken: CancellationToken | undefined;
+        // Mirror the tool: a canceled execution resolves with an empty diff.
+        gitChangesTool.getStagedChanges.callsFake((_repository: unknown, token: CancellationToken) => {
+            capturedToken = token;
+            return new Promise<string>(resolve => token.onCancellationRequested(() => resolve('')));
+        });
+
+        const runPromise = runner.run();
+        await new Promise(resolve => setTimeout(resolve, 0));
+        expect(capturedToken?.isCancellationRequested).to.be.false;
+
+        runner.cancel();
+        await runPromise;
+
+        expect(capturedToken?.isCancellationRequested).to.be.true;
+        expect(agent.generateCommitMessage.called).to.be.false;
+        expect(runner.isRunning()).to.be.false;
+    });
+});