@theia/ai-chat 1.74.0-next.9 → 1.74.1

package/src/common/chat-request-parser.spec.ts

@@ -20,17 +20,29 @@ import { ChatRequestParserImpl } from './chat-request-parser';
 import { ChatAgent, ChatAgentLocation } from './chat-agents';
 import { ChatContext, ChatRequest } from './chat-model';
 import { expect } from 'chai';
-import { AIVariable, DefaultAIVariableService, ResolvedAIVariable, ToolInvocationRegistryImpl, ToolRequest } from '@theia/ai-core';
+import { AIVariable, DefaultAIVariableService, PromptService, ResolvedAIVariable, ToolInvocationRegistryImpl, ToolRequest } from '@theia/ai-core';
 import { ILogger, Logger } from '@theia/core';
 import { ParsedChatRequestAgentPart, ParsedChatRequestFunctionPart, ParsedChatRequestTextPart, ParsedChatRequestVariablePart } from './parsed-chat-request';
 import { AgentDelegationTool } from '../browser/agent-delegation-tool';
 
 describe('ChatRequestParserImpl', () => {
+    /** Command names the stubbed `PromptService` knows about. Anything else is not a command. */
+    const KNOWN_COMMANDS = ['hello', 'explain', 'compare', 'cmd', 'summarize', 'skill-one', 'skill-two'];
+    /** Prompt fragments that are not marked as commands, but can still be invoked by their id. */
+    const KNOWN_FRAGMENT_IDS = ['coder-system'];
+
+    const promptService = {
+        isKnownCommand: (name: string) => KNOWN_COMMANDS.includes(name) || KNOWN_FRAGMENT_IDS.includes(name),
+        getCommands: () => KNOWN_COMMANDS.map(name => ({ id: `command-${name}`, template: '', isCommand: true, commandName: name }))
+    } as unknown as PromptService;
+
     const chatAgentService = sinon.createStubInstance(ChatAgentServiceImpl);
     const variableService = sinon.createStubInstance(DefaultAIVariableService);
     const toolInvocationRegistry = sinon.createStubInstance(ToolInvocationRegistryImpl);
     const logger: ILogger = sinon.createStubInstance(Logger);
     const parser = new ChatRequestParserImpl(chatAgentService, variableService, toolInvocationRegistry, logger);
+    // The parser injects the PromptService as a property, so it has to be assigned manually here.
+    (parser as unknown as { promptService: PromptService }).promptService = promptService;
 
     beforeEach(() => {
         // Reset our stubs before each test
@@ -276,6 +288,66 @@ describe('ChatRequestParserImpl', () => {
         expect(varPart.variableArg).to.equal('cmd|"arg with \\"quote\\"" other');
     });
 
+    it('parses multiple commands in one message', async () => {
+        const req: ChatRequest = {
+            text: '/skill-one /skill-two'
+        };
+        const context: ChatContext = { variables: [] };
+        const result = await parser.parseChatRequest(req, ChatAgentLocation.Panel, context);
+
+        expect(result.parts.length).to.equal(3);
+        const firstCommand = result.parts[0] as ParsedChatRequestVariablePart;
+        const separator = result.parts[1] as ParsedChatRequestTextPart;
+        const secondCommand = result.parts[2] as ParsedChatRequestVariablePart;
+        expect(firstCommand.variableName).to.equal('prompt');
+        expect(firstCommand.variableArg).to.equal('skill-one');
+        expect(separator.text).to.equal(' ');
+        expect(secondCommand.variableName).to.equal('prompt');
+        expect(secondCommand.variableArg).to.equal('skill-two');
+    });
+
+    it('inserts a separator between two argument-taking commands', async () => {
+        const req: ChatRequest = {
+            text: '/summarize foo /hello bar'
+        };
+        const context: ChatContext = { variables: [] };
+        const result = await parser.parseChatRequest(req, ChatAgentLocation.Panel, context);
+
+        expect(result.parts.length).to.equal(3);
+        const firstCommand = result.parts[0] as ParsedChatRequestVariablePart;
+        const separator = result.parts[1] as ParsedChatRequestTextPart;
+        const secondCommand = result.parts[2] as ParsedChatRequestVariablePart;
+        expect(firstCommand.variableArg).to.equal('summarize|foo');
+        expect(separator.kind).to.equal('text');
+        expect(separator.text).to.equal(' ');
+        expect(secondCommand.variableArg).to.equal('hello|bar');
+    });
+
+    it('keeps path-like slash arguments as command arguments', async () => {
+        const req: ChatRequest = {
+            text: '/explain /path/to/file'
+        };
+        const context: ChatContext = { variables: [] };
+        const result = await parser.parseChatRequest(req, ChatAgentLocation.Panel, context);
+
+        expect(result.parts.length).to.equal(1);
+        const varPart = result.parts[0] as ParsedChatRequestVariablePart;
+        expect(varPart.variableName).to.equal('prompt');
+        expect(varPart.variableArg).to.equal('explain|/path/to/file');
+    });
+
+    it('does not treat path segments as commands', async () => {
+        const req: ChatRequest = {
+            text: 'please look at /home/user/notes.txt and fix the bug'
+        };
+        const context: ChatContext = { variables: [] };
+        const result = await parser.parseChatRequest(req, ChatAgentLocation.Panel, context);
+
+        expect(result.parts.length).to.equal(1);
+        expect(result.parts[0].kind).to.equal('text');
+        expect(result.parts[0].text).to.equal(req.text);
+    });
+
     it('treats the first @agent mention as the selector and does not allow later mentions to override it', async () => {
         const createAgent = (id: string): ChatAgent => ({
             id,
@@ -457,6 +529,334 @@ describe('ChatRequestParserImpl', () => {
         });
     });
 
+    describe('slash command disambiguation', () => {
+        const parse = (text: string) => parser.parseChatRequest({ text }, ChatAgentLocation.Panel, { variables: [] });
+
+        /** Every character of the input has to be covered by exactly one part, in order and without gaps. */
+        const expectFullCoverage = (parts: ReadonlyArray<{ range: { start: number, endExclusive: number } }>, text: string): void => {
+            let expectedStart = 0;
+            for (const part of parts) {
+                expect(part.range.start, `part starting at ${part.range.start} does not continue at ${expectedStart}`).to.equal(expectedStart);
+                expectedStart = part.range.endExclusive;
+            }
+            expect(expectedStart, 'parts do not cover the whole message').to.equal(text.length);
+        };
+
+        const expectPlainText = async (text: string) => {
+            const result = await parse(text);
+            expect(result.parts.map(p => p.kind), `expected only text parts for ${JSON.stringify(text)}`).to.deep.equal(['text']);
+            expect(result.parts[0].text).to.equal(text);
+            expectFullCoverage(result.parts, text);
+        };
+
+        describe('unknown commands stay plain text', () => {
+            const unknownCommandInputs = [
+                'please look at /home/user/notes.txt and fix the bug',
+                '/home/user/notes.txt is broken',
+                'read /usr/local/bin/theia',
+                'the file is at /etc/hosts',
+                'compare /tmp/a.txt with /tmp/b.txt',
+                'run cd /home && ls',
+                'see /usr/lib/node/foo.js:12 for the stack trace',
+                'what does the option --foo /bar do?',
+                '/does-not-exist do something',
+                '/tmp',
+                'move it to /tmp',
+                'the separator is / on Unix'
+            ];
+
+            unknownCommandInputs.forEach(text => {
+                it(`keeps ${JSON.stringify(text)} as plain text`, () => expectPlainText(text));
+            });
+
+            it('does not drop any user text when a path follows a known command name prefix', async () => {
+                // `/summarizes` is not a known command, even though `/summarize` is.
+                await expectPlainText('/summarizes the file');
+            });
+
+            it('does not treat a known command name as a command when it is a path segment', async () => {
+                // `summarize` is known, but `/summarize/foo` is a path, not a command invocation.
+                await expectPlainText('/summarize/foo is a path');
+            });
+
+            it('does not treat a known command name followed by punctuation as a command', async () => {
+                await expectPlainText('did you mean /summarize?');
+            });
+        });
+
+        describe('slashes that are not command leaders', () => {
+            const nonLeaderInputs = [
+                'A: 10/20 and B: 30/40',
+                'use and/or here',
+                '2026/08/04 is the date',
+                'see https://example.com/foo/bar for details',
+                'the regex is a\\/b'
+            ];
+
+            nonLeaderInputs.forEach(text => {
+                it(`keeps ${JSON.stringify(text)} as plain text`, () => expectPlainText(text));
+            });
+        });
+
+        describe('known commands still parse', () => {
+            it('parses a known command without arguments', async () => {
+                const text = '/summarize';
+                const result = await parse(text);
+
+                expect(result.parts.length).to.equal(1);
+                const command = result.parts[0] as ParsedChatRequestVariablePart;
+                expect(command.variableName).to.equal('prompt');
+                expect(command.variableArg).to.equal('summarize');
+                expectFullCoverage(result.parts, text);
+            });
+
+            it('parses a known command with arguments', async () => {
+                const text = '/summarize foo bar';
+                const result = await parse(text);
+
+                expect(result.parts.length).to.equal(1);
+                expect((result.parts[0] as ParsedChatRequestVariablePart).variableArg).to.equal('summarize|foo bar');
+                expectFullCoverage(result.parts, text);
+            });
+
+            it('keeps a path as the argument of a known command', async () => {
+                const text = '/summarize /home/user/notes.txt';
+                const result = await parse(text);
+
+                expect(result.parts.length).to.equal(1);
+                expect((result.parts[0] as ParsedChatRequestVariablePart).variableArg).to.equal('summarize|/home/user/notes.txt');
+                expectFullCoverage(result.parts, text);
+            });
+
+            it('keeps an unknown slash token inside the arguments of a known command', async () => {
+                const text = '/summarize foo /unknown bar';
+                const result = await parse(text);
+
+                expect(result.parts.length).to.equal(1);
+                expect((result.parts[0] as ParsedChatRequestVariablePart).variableArg).to.equal('summarize|foo /unknown bar');
+                expectFullCoverage(result.parts, text);
+            });
+
+            it('parses a known command in the middle of a message', async () => {
+                const text = 'please /summarize this';
+                const result = await parse(text);
+
+                expect(result.parts.map(p => p.kind)).to.deep.equal(['text', 'var']);
+                expect(result.parts[0].text).to.equal('please ');
+                expect((result.parts[1] as ParsedChatRequestVariablePart).variableArg).to.equal('summarize|this');
+                expectFullCoverage(result.parts, text);
+            });
+
+            it('parses two adjacent known commands', async () => {
+                const text = '/skill-one /skill-two';
+                const result = await parse(text);
+
+                expect(result.parts.map(p => p.kind)).to.deep.equal(['var', 'text', 'var']);
+                expect((result.parts[0] as ParsedChatRequestVariablePart).variableArg).to.equal('skill-one');
+                expect(result.parts[1].text).to.equal(' ');
+                expect((result.parts[2] as ParsedChatRequestVariablePart).variableArg).to.equal('skill-two');
+                expectFullCoverage(result.parts, text);
+            });
+
+            it('separates two argument-taking known commands', async () => {
+                const text = '/summarize foo /explain bar';
+                const result = await parse(text);
+
+                expect(result.parts.map(p => p.kind)).to.deep.equal(['var', 'text', 'var']);
+                expect((result.parts[0] as ParsedChatRequestVariablePart).variableArg).to.equal('summarize|foo');
+                expect(result.parts[1].text).to.equal(' ');
+                expect((result.parts[2] as ParsedChatRequestVariablePart).variableArg).to.equal('explain|bar');
+                expectFullCoverage(result.parts, text);
+            });
+
+            it('parses the same command twice, each with its own argument', async () => {
+                const text = '/hello Klaus /hello Maria';
+                const result = await parse(text);
+
+                expect(result.parts.map(p => p.kind)).to.deep.equal(['var', 'text', 'var']);
+                expect((result.parts[0] as ParsedChatRequestVariablePart).variableArg).to.equal('hello|Klaus');
+                expect(result.parts[1].text).to.equal(' ');
+                expect((result.parts[2] as ParsedChatRequestVariablePart).variableArg).to.equal('hello|Maria');
+                expectFullCoverage(result.parts, text);
+            });
+
+            it('parses the same command three times', async () => {
+                const text = '/hello Klaus /hello Maria /hello Bob';
+                const result = await parse(text);
+
+                expect(result.parts.map(p => p.kind)).to.deep.equal(['var', 'text', 'var', 'text', 'var']);
+                expect((result.parts[0] as ParsedChatRequestVariablePart).variableArg).to.equal('hello|Klaus');
+                expect((result.parts[2] as ParsedChatRequestVariablePart).variableArg).to.equal('hello|Maria');
+                expect((result.parts[4] as ParsedChatRequestVariablePart).variableArg).to.equal('hello|Bob');
+                expectFullCoverage(result.parts, text);
+            });
+
+            it('parses the same command twice without arguments', async () => {
+                const text = '/hello /hello';
+                const result = await parse(text);
+
+                expect(result.parts.map(p => p.kind)).to.deep.equal(['var', 'text', 'var']);
+                expect((result.parts[0] as ParsedChatRequestVariablePart).variableArg).to.equal('hello');
+                expect(result.parts[1].text).to.equal(' ');
+                expect((result.parts[2] as ParsedChatRequestVariablePart).variableArg).to.equal('hello');
+                expectFullCoverage(result.parts, text);
+            });
+
+            it('accepts a prompt fragment id as a command', async () => {
+                const text = '/coder-system';
+                const result = await parse(text);
+
+                expect(result.parts.length).to.equal(1);
+                expect((result.parts[0] as ParsedChatRequestVariablePart).variableArg).to.equal('coder-system');
+            });
+
+            it('keeps trailing whitespace out of the command part', async () => {
+                const text = '/summarize   ';
+                const result = await parse(text);
+
+                expect(result.parts.map(p => p.kind)).to.deep.equal(['var', 'text']);
+                expect((result.parts[0] as ParsedChatRequestVariablePart).variableArg).to.equal('summarize');
+                expect(result.parts[1].text).to.equal('   ');
+                expectFullCoverage(result.parts, text);
+            });
+
+            it('trims whitespace around arguments', async () => {
+                const text = '/summarize \t foo \t ';
+                const result = await parse(text);
+
+                expect((result.parts[0] as ParsedChatRequestVariablePart).variableArg).to.equal('summarize|foo');
+                expectFullCoverage(result.parts, text);
+            });
+        });
+
+        describe('arguments do not span multiple lines', () => {
+            it('does not consume the following line for a command without arguments', async () => {
+                const text = '/summarize\nsecond line';
+                const result = await parse(text);
+
+                expect(result.parts.map(p => p.kind)).to.deep.equal(['var', 'text']);
+                expect((result.parts[0] as ParsedChatRequestVariablePart).variableArg).to.equal('summarize');
+                expect(result.parts[1].text).to.equal('\nsecond line');
+                expectFullCoverage(result.parts, text);
+            });
+
+            it('does not consume the following line for a command with arguments', async () => {
+                const text = '/summarize foo\nsecond line\nthird line';
+                const result = await parse(text);
+
+                expect(result.parts.map(p => p.kind)).to.deep.equal(['var', 'text']);
+                expect((result.parts[0] as ParsedChatRequestVariablePart).variableArg).to.equal('summarize|foo');
+                expect(result.parts[1].text).to.equal('\nsecond line\nthird line');
+                expectFullCoverage(result.parts, text);
+            });
+
+            it('handles CRLF line endings', async () => {
+                const text = '/summarize foo\r\nsecond line';
+                const result = await parse(text);
+
+                expect(result.parts.map(p => p.kind)).to.deep.equal(['var', 'text']);
+                expect((result.parts[0] as ParsedChatRequestVariablePart).variableArg).to.equal('summarize|foo');
+                expect(result.parts[1].text).to.equal('\r\nsecond line');
+                expectFullCoverage(result.parts, text);
+            });
+
+            it('parses a command on a later line', async () => {
+                const text = 'first line\n/summarize foo\nthird line';
+                const result = await parse(text);
+
+                expect(result.parts.map(p => p.kind)).to.deep.equal(['text', 'var', 'text']);
+                expect(result.parts[0].text).to.equal('first line\n');
+                expect((result.parts[1] as ParsedChatRequestVariablePart).variableArg).to.equal('summarize|foo');
+                expect(result.parts[2].text).to.equal('\nthird line');
+                expectFullCoverage(result.parts, text);
+            });
+
+            it('parses one command per line', async () => {
+                const text = '/summarize foo\n/explain bar';
+                const result = await parse(text);
+
+                expect(result.parts.map(p => p.kind)).to.deep.equal(['var', 'text', 'var']);
+                expect((result.parts[0] as ParsedChatRequestVariablePart).variableArg).to.equal('summarize|foo');
+                expect(result.parts[1].text).to.equal('\n');
+                expect((result.parts[2] as ParsedChatRequestVariablePart).variableArg).to.equal('explain|bar');
+                expectFullCoverage(result.parts, text);
+            });
+
+            it('parses the same command on consecutive lines', async () => {
+                const text = '/hello Klaus\n/hello Maria';
+                const result = await parse(text);
+
+                expect(result.parts.map(p => p.kind)).to.deep.equal(['var', 'text', 'var']);
+                expect((result.parts[0] as ParsedChatRequestVariablePart).variableArg).to.equal('hello|Klaus');
+                expect(result.parts[1].text).to.equal('\n');
+                expect((result.parts[2] as ParsedChatRequestVariablePart).variableArg).to.equal('hello|Maria');
+                expectFullCoverage(result.parts, text);
+            });
+
+            it('keeps a blank line between two commands', async () => {
+                const text = '/hello Klaus\n\n/hello Maria';
+                const result = await parse(text);
+
+                expect(result.parts.map(p => p.kind)).to.deep.equal(['var', 'text', 'var']);
+                expect((result.parts[0] as ParsedChatRequestVariablePart).variableArg).to.equal('hello|Klaus');
+                expect(result.parts[1].text).to.equal('\n\n');
+                expect((result.parts[2] as ParsedChatRequestVariablePart).variableArg).to.equal('hello|Maria');
+                expectFullCoverage(result.parts, text);
+            });
+
+            it('mixes a line break with a repetition on the same line', async () => {
+                const text = '/hello Klaus\n/hello Maria and /hello Bob';
+                const result = await parse(text);
+
+                expect(result.parts.map(p => p.kind)).to.deep.equal(['var', 'text', 'var', 'text', 'var']);
+                expect((result.parts[0] as ParsedChatRequestVariablePart).variableArg).to.equal('hello|Klaus');
+                expect(result.parts[1].text).to.equal('\n');
+                expect((result.parts[2] as ParsedChatRequestVariablePart).variableArg).to.equal('hello|Maria and');
+                expect(result.parts[3].text).to.equal(' ');
+                expect((result.parts[4] as ParsedChatRequestVariablePart).variableArg).to.equal('hello|Bob');
+                expectFullCoverage(result.parts, text);
+            });
+
+            it('keeps a multi-line paste containing paths untouched', async () => {
+                await expectPlainText('here is a stack trace:\n at /usr/lib/node/foo.js:12\nplease fix it');
+            });
+        });
+
+        describe('interaction with other request parts', () => {
+            it('does not turn a path into a command when it follows a variable', async () => {
+                const text = '#file:/path/to/file.ext look at /home/user/notes.txt';
+                const result = await parse(text);
+
+                expect(result.parts.map(p => p.kind)).to.deep.equal(['var', 'text']);
+                expect((result.parts[0] as ParsedChatRequestVariablePart).variableName).to.equal('file');
+                expect(result.parts[1].text).to.equal(' look at /home/user/notes.txt');
+                expectFullCoverage(result.parts, text);
+            });
+
+            it('does not turn a path into a command when it follows an agent mention', async () => {
+                chatAgentService.getAgents.returns([{
+                    id: 'agentA',
+                    name: 'agentA',
+                    description: '',
+                    tags: [],
+                    variables: [],
+                    prompts: [],
+                    agentSpecificVariables: [],
+                    functions: [],
+                    languageModelRequirements: [],
+                    locations: [ChatAgentLocation.Panel],
+                    invoke: async () => undefined
+                } as ChatAgent]);
+                const text = '@agentA please read /etc/hosts';
+                const result = await parse(text);
+
+                expect(result.parts.map(p => p.kind)).to.deep.equal(['agent', 'text']);
+                expect(result.parts[1].text).to.equal(' please read /etc/hosts');
+                expectFullCoverage(result.parts, text);
+            });
+        });
+    });
+
     describe('parsed chat request part kind assignments', () => {
         it('ParsedChatRequestTextPart has kind assigned at runtime', () => {
             const part = new ParsedChatRequestTextPart({ start: 0, endExclusive: 5 }, 'hello');

package/src/common/chat-request-parser.ts

@@ -37,7 +37,7 @@ import {
     ParsedChatRequestPart,
 } from './parsed-chat-request';
 import {
-    AIVariable, AIVariableService, createAIResolveVariableCache, getAllResolvedAIVariables, parseFunctionReference, ToolInvocationRegistry, ToolRequest
+    AIVariable, AIVariableService, createAIResolveVariableCache, getAllResolvedAIVariables, parseFunctionReference, PromptService, ToolInvocationRegistry, ToolRequest
 } from '@theia/ai-core';
 import { ILogger } from '@theia/core';
 
@@ -47,7 +47,11 @@ const agentReg = /^@([\w_\-\.]+)(?=(\s|$|\b))/i; // An @-agent
 const functionReg = /^~(\??[\w_\-\.]+)(?=(\s|$|\b))/i;
 const functionPromptFormatReg = /^\~\{\s*(.*?)\s*\}/i;
 const variableReg = /^#([\w_\-]+)(?::([\w_\-_\/\\.:]+))?(?=(\s|$|\b))/i; // A #-variable with an optional : arg (#file:workspace/path/name.ext)
-const commandReg = /^\/([\w_\-]+)(?:\s+(.+?))?(?=\s*$)/; // A /-command with optional arguments (/commandname arg1 arg2)
+// A /-command (/commandname) with optional arguments parsed separately. The command name must be
+// terminated by whitespace or the end of the input, so that path segments such as `/home/user` are
+// not mistaken for a command.
+const commandReg = /^\/([\w_\-]+)(?=\s|$)/;
+const nextCommandReg = /\s+\/([\w_\-]+)(?=\s|$)/g;
 
 export const ChatRequestParser = Symbol('ChatRequestParser');
 export interface ChatRequestParser {
@@ -62,11 +66,15 @@ function offsetRange(start: number, endExclusive: number): OffsetRange {
 }
 @injectable()
 export class ChatRequestParserImpl implements ChatRequestParser {
+
+    @inject(PromptService)
+    protected readonly promptService: PromptService;
+
     constructor(
         @inject(ChatAgentService) private readonly agentService: ChatAgentService,
         @inject(AIVariableService) private readonly variableService: AIVariableService,
         @inject(ToolInvocationRegistry) private readonly toolInvocationRegistry: ToolInvocationRegistry,
-        @inject(ILogger) private readonly logger: ILogger
+        @inject(ILogger) private readonly logger: ILogger,
     ) { }
 
     async parseChatRequest(request: ChatRequest, location: ChatAgentLocation, context: ChatContext): Promise<ParsedChatRequest> {
@@ -185,6 +193,7 @@ export class ChatRequestParserImpl implements ChatRequestParser {
                 }
 
                 parts.push(newPart);
+                i = newPart.range.endExclusive - 1;
             }
         }
 
@@ -292,13 +301,59 @@ export class ChatRequestParserImpl implements ChatRequestParser {
             return;
         }
 
-        const [full, commandName, commandArgs] = nextCommandMatch;
-        const commandRange = offsetRange(offset, offset + full.length);
+        const [commandText, commandName] = nextCommandMatch;
+        if (!this.isCommandCandidate(commandName)) {
+            // Not a command we know about, so leave the text alone. Otherwise anything the user
+            // types after a `/word` token, e.g. a Unix path, would be swallowed as command
+            // arguments and silently dropped when the non-existing command fails to resolve.
+            return;
+        }
+        let commandEnd = commandText.length;
+        let commandArgs: string | undefined;
+
+        // Arguments never span multiple lines: a command only consumes the remainder of its own line.
+        const lineBreakOffset = message.indexOf('\n', commandEnd);
+        const lineEnd = lineBreakOffset === -1 ? message.length : lineBreakOffset;
+        const nextCommandOffset = this.findNextCommandOffset(message, commandEnd, lineEnd);
+        const argsEnd = nextCommandOffset ?? lineEnd;
+        const rawArgs = message.slice(commandEnd, argsEnd);
+        const args = rawArgs.trim();
+        if (args) {
+            commandArgs = args;
+            // Advance the consumed range only up to the end of the trimmed argument, not up to the
+            // next command. This keeps the whitespace between the argument and a following command
+            // out of this part's range, so parseParts emits it as a separator text part. Otherwise
+            // the two resolved prompt fragments would run into each other with no space between them.
+            commandEnd = argsEnd - (rawArgs.length - rawArgs.trimEnd().length);
+        }
+
+        const commandRange = offsetRange(offset, offset + commandEnd);
 
         const variableArg = commandArgs ? `${commandName}|${commandArgs}` : commandName;
         return new ParsedChatRequestVariablePart(commandRange, 'prompt', variableArg);
     }
 
+    private findNextCommandOffset(message: string, startOffset: number, endOffset: number): number | undefined {
+        nextCommandReg.lastIndex = startOffset;
+        let match = nextCommandReg.exec(message);
+        while (match && match.index < endOffset) {
+            if (this.isCommandCandidate(match[1])) {
+                return match.index + match[0].indexOf(chatSubcommandLeader);
+            }
+            match = nextCommandReg.exec(message);
+        }
+        return undefined;
+    }
+
+    /**
+     * Whether a `/name` token should be treated as a command. Only names that actually resolve to a
+     * command or prompt fragment are accepted, which keeps unknown `/word` tokens (e.g. `/tmp`,
+     * `/path/to/file`) as plain text.
+     */
+    protected isCommandCandidate(commandName: string): boolean {
+        return this.promptService.isKnownCommand(commandName);
+    }
+
     private tryToParseFunction(message: string, offset: number): ParsedChatRequestFunctionPart | undefined {
         // Support both the chat and prompt formats for functions
         const nextFunctionMatch = message.match(functionPromptFormatReg) || message.match(functionReg);

package/src/common/chat-response-model.spec.ts

@@ -15,7 +15,7 @@
 // *****************************************************************************
 
 import { expect } from 'chai';
-import { MutableChatResponseModel, ToolCallChatResponseContentImpl } from './chat-model';
+import { MarkdownChatResponseContentImpl, MutableChatResponseModel, ToolCallChatResponseContentImpl } from './chat-model';
 
 describe('MutableChatResponseModel', () => {
     describe('content change propagation', () => {
@@ -35,6 +35,46 @@ describe('MutableChatResponseModel', () => {
             // lost on reload.
             expect(fireCount).to.equal(1);
         });
+
+        it('should not accumulate duplicate listeners when content is cleared and re-added', () => {
+            const response = new MutableChatResponseModel('req-1');
+            const toolCall = new ToolCallChatResponseContentImpl('tool-1', 'tool', '{}', false);
+            response.response.addContent(toolCall);
+
+            // Simulate AbstractStreamParsingChatAgent.addStreamResponse: for every streamed
+            // text token, the whole content is cleared and re-added, tool call included.
+            for (let i = 0; i < 10; i++) {
+                const contentBeforeMarker = response.response.content.slice(0, 1);
+                response.response.clearContent();
+                response.response.addContents(contentBeforeMarker);
+                response.response.addContents([new MarkdownChatResponseContentImpl(`token ${i}`)]);
+            }
+
+            let fireCount = 0;
+            response.onDidChange(() => { fireCount++; });
+
+            toolCall.updateResult('result');
+
+            // A single tool call change must fire exactly once, no matter how often the
+            // content array was rebuilt during streaming (see #17858).
+            expect(fireCount).to.equal(1);
+        });
+
+        it('should stop propagating changes of content that was cleared and not re-added', () => {
+            const response = new MutableChatResponseModel('req-1');
+            const toolCall = new ToolCallChatResponseContentImpl('tool-1', 'tool', '{}', false);
+            response.response.addContent(toolCall);
+            response.response.clearContent();
+
+            let fireCount = 0;
+            response.onDidChange(() => { fireCount++; });
+
+            toolCall.updateResult('result');
+
+            // Content that is no longer part of the response must not trigger response changes
+            // (and with that auto-save) anymore.
+            expect(fireCount).to.equal(0);
+        });
     });
 
     describe('setTokenUsage', () => {

package/src/common/chat-service-deletion.spec.ts

@@ -267,6 +267,58 @@ describe('ChatService Session Deletion', () => {
             expect(sessionStore.deletedSessions).to.include(persistedSessionId);
         });
 
+        it('should cascade-delete descendants when deleting an intermediate session (A -> B -> C, in memory)', async () => {
+            // Delegation chain A -> B -> C, all loaded in memory. C's rootSessionId points at A (the
+            // root of the chain), but its immediate parent is B, so deleting B must still remove C.
+            const a = chatService.createSession(ChatAgentLocation.Panel);
+            const b = chatService.createSession(ChatAgentLocation.Panel);
+            const c = chatService.createSession(ChatAgentLocation.Panel);
+            const internal = b as unknown as { rootSessionId?: string; parentSessionId?: string };
+            internal.rootSessionId = a.id;
+            internal.parentSessionId = a.id;
+            const cInternal = c as unknown as { rootSessionId?: string; parentSessionId?: string };
+            cInternal.rootSessionId = a.id;
+            cInternal.parentSessionId = b.id;
+
+            await chatService.deleteSession(b.id);
+
+            const remaining = chatService.getSessions().map(s => s.id);
+            expect(remaining).to.include(a.id);
+            expect(remaining).to.not.include(b.id);
+            expect(remaining).to.not.include(c.id);
+            expect(sessionStore.deletedSessions).to.include(b.id);
+            expect(sessionStore.deletedSessions).to.include(c.id);
+        });
+
+        it('should cascade-delete persisted-only descendants of an intermediate session', async () => {
+            // The whole chain lives only in the persisted index (e.g. after a reload). Deleting the
+            // intermediate B must reach C via its parentSessionId even though C's rootSessionId is A.
+            sessionStore.getSessionIndex = async (): Promise<ChatSessionIndex> => ({
+                A: { sessionId: 'A', title: 'A', saveDate: 0, location: ChatAgentLocation.Panel },
+                B: { sessionId: 'B', title: 'B', saveDate: 0, location: ChatAgentLocation.Panel, rootSessionId: 'A', parentSessionId: 'A' },
+                C: { sessionId: 'C', title: 'C', saveDate: 0, location: ChatAgentLocation.Panel, rootSessionId: 'A', parentSessionId: 'B' }
+            });
+
+            await chatService.deleteSession('B');
+
+            expect(sessionStore.deletedSessions).to.include('B');
+            expect(sessionStore.deletedSessions).to.include('C');
+            expect(sessionStore.deletedSessions).to.not.include('A');
+        });
+
+        it('should not loop forever on a cyclic parent reference', async () => {
+            // Defensive: a corrupted index where two sessions reference each other must still terminate.
+            sessionStore.getSessionIndex = async (): Promise<ChatSessionIndex> => ({
+                X: { sessionId: 'X', title: 'X', saveDate: 0, location: ChatAgentLocation.Panel, parentSessionId: 'Y' },
+                Y: { sessionId: 'Y', title: 'Y', saveDate: 0, location: ChatAgentLocation.Panel, parentSessionId: 'X' }
+            });
+
+            await chatService.deleteSession('X');
+
+            expect(sessionStore.deletedSessions).to.include('X');
+            expect(sessionStore.deletedSessions).to.include('Y');
+        });
+
         it('should fire SessionDeletedEvent for persisted-only sessions', async () => {
             // When deleting a persisted-only session (not in memory),
             // we still fire the event so consumers (e.g. the Welcome view's chat cards)