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

package/src/common/chat-content-deserializer.ts

@@ -19,6 +19,8 @@ import {
     ChatResponseContent,
     CodeChatResponseContentImpl,
     CommandChatResponseContentImpl,
+    CompactionChatResponseContentImpl,
+    CompactionContentData,
     ErrorChatResponseContentImpl,
     HorizontalLayoutChatResponseContentImpl,
     InformationalChatResponseContentImpl,
@@ -250,6 +252,15 @@ export class DefaultChatContentDeserializerContribution implements ChatContentDe
             )
         });
 
+        registry.register({
+            kind: 'compaction',
+            deserialize: (data: CompactionContentData) => new CompactionChatResponseContentImpl(
+                data.provider,
+                data.data,
+                data.summary
+            )
+        });
+
         registry.register({
             kind: 'markdownContent',
             deserialize: (data: MarkdownContentData) => new MarkdownChatResponseContentImpl(data.content)

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

@@ -700,4 +700,42 @@ describe('ChatModel Serialization and Restoration', () => {
             expect(restoredPart.resolution?.variable.description).to.equal('File variable');
         });
     });
+
+    describe('Session settings and response model serialization', () => {
+        it('should serialize and restore the per-session model override', () => {
+            const model = new MutableChatModel(ChatAgentLocation.Panel);
+            model.addRequest(createParsedRequest('Hello'));
+            model.setSettings({ commonSettings: { modelId: 'anthropic/claude-opus-4-8' } });
+
+            const serialized = model.toSerializable();
+            expect(serialized.settings?.commonSettings?.modelId).to.equal('anthropic/claude-opus-4-8');
+
+            const restored = new MutableChatModel(serialized);
+            expect(restored.settings?.commonSettings?.modelId).to.equal('anthropic/claude-opus-4-8');
+        });
+
+        it('should leave settings undefined when none were set', () => {
+            const model = new MutableChatModel(ChatAgentLocation.Panel);
+            model.addRequest(createParsedRequest('Hello'));
+
+            const serialized = model.toSerializable();
+            expect(serialized.settings).to.be.undefined;
+
+            const restored = new MutableChatModel(serialized);
+            expect(restored.settings).to.be.undefined;
+        });
+
+        it('should serialize and restore the language model recorded on a response', () => {
+            const model = new MutableChatModel(ChatAgentLocation.Panel);
+            const request = model.addRequest(createParsedRequest('Hello'));
+            request.response.setLanguageModel('anthropic/claude-opus-4-8');
+            request.response.complete();
+
+            const serialized = model.toSerializable();
+            expect(serialized.responses[0].languageModel).to.equal('anthropic/claude-opus-4-8');
+
+            const restored = new MutableChatModel(serialized);
+            expect(restored.getAllRequests()[0].response.languageModel).to.equal('anthropic/claude-opus-4-8');
+        });
+    });
 });

package/src/common/chat-model-serialization.ts

@@ -16,7 +16,7 @@
 
 import { GenericCapabilitySelections } from '@theia/ai-core';
 import { ChatAgentLocation } from './chat-agents';
-import { ResponseTokenUsage } from './chat-model';
+import { ChatSessionSettings, ResponseTokenUsage } from './chat-model';
 
 export interface SerializableChangeSetElement {
     kind?: string;
@@ -138,6 +138,8 @@ export interface SerializableChatResponseData {
     errorMessage?: string;
     promptVariantId?: string;
     isPromptVariantEdited?: boolean;
+    /** Identifier of the language model that produced this response, if recorded. */
+    languageModel?: string;
     tokenUsage?: ResponseTokenUsage;
     content: SerializableChatResponseContentData[];
 }
@@ -189,6 +191,11 @@ export interface SerializedChatModel {
     requests: SerializableChatRequestData[];
     /** All responses for the requests */
     responses: SerializableChatResponseData[];
+    /**
+     * Per-session settings (e.g. the per-session model override) so they survive a reload and the
+     * chat input can restore the correct selection.
+     */
+    settings?: ChatSessionSettings;
 }
 
 /**
@@ -201,6 +208,10 @@ export interface SerializedChatData {
     title?: string;
     model: SerializedChatModel;
     saveDate: number;
+    /** ID of the root session in the delegation chain. */
+    rootSessionId?: string;
+    /** ID of the immediate parent session that delegated this one. */
+    parentSessionId?: string;
 }
 
 export interface SerializableChatsData {

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

@@ -0,0 +1,42 @@
+// *****************************************************************************
+// 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 { CompactionChatResponseContentImpl, CompactionChatResponseContent } from './chat-model';
+
+describe('CompactionChatResponseContent', () => {
+    it('round-trips through serialization', () => {
+        const original = new CompactionChatResponseContentImpl('anthropic', { block: 'opaque' }, 'summary text');
+        const serialized = original.toSerializable();
+        expect(serialized.kind).to.equal('compaction');
+        const restored = new CompactionChatResponseContentImpl(
+            serialized.data.provider, serialized.data.data, serialized.data.summary);
+        expect(restored.provider).to.equal('anthropic');
+        expect(restored.summary).to.equal('summary text');
+        expect(restored.data).to.deep.equal({ block: 'opaque' });
+    });
+    it('produces a compaction language model message', () => {
+        const content = new CompactionChatResponseContentImpl('openai-responses', { item: 'x' });
+        const message = content.toLanguageModelMessage();
+        expect(message).to.deep.equal({ actor: 'ai', type: 'compaction', provider: 'openai-responses', data: { item: 'x' }, summary: undefined });
+    });
+    it('is excluded from plain-text history but offers a display string', () => {
+        const content = new CompactionChatResponseContentImpl('anthropic', {}, 'sum');
+        expect(content.asString()).to.equal(undefined);
+        expect(content.asDisplayString()).to.equal('sum');
+        expect(CompactionChatResponseContent.is(content)).to.equal(true);
+    });
+});

package/src/common/chat-model.ts

@@ -21,6 +21,8 @@
 
 import {
     AIVariableResolutionRequest,
+    CompactionMessage,
+    CompactionSettings,
     GenericCapabilitySelections,
     LanguageModelMessage,
     ReasoningSettings,
@@ -80,7 +82,9 @@ export type ChatChangeEvent =
     | ChatEditSubmitEvent
     | ChatResponseChangedEvent
     | ChatChangeHierarchyBranchEvent
-    | ChatInteractionNeededEvent;
+    | ChatInteractionNeededEvent
+    | ChatSessionStatusChangedEvent
+    | ChatSettingsChangedEvent;
 
 export interface ChatAddRequestEvent {
     kind: 'addRequest';
@@ -142,6 +146,16 @@ export interface ChatInteractionNeededEvent {
     contentPart: InteractiveContent & ChatResponseContent;
 }
 
+export interface ChatSessionStatusChangedEvent {
+    kind: 'statusChanged';
+    status: ChatSessionStatus;
+}
+
+export interface ChatSettingsChangedEvent {
+    kind: 'settingsChanged';
+    settings: ChatSessionSettings;
+}
+
 export namespace ChatChangeEvent {
     export function isChangeSetEvent(event: ChatChangeEvent): event is ChatUpdateChangeSetEvent {
         return event.kind === 'updateChangeSet';
@@ -149,6 +163,9 @@ export namespace ChatChangeEvent {
     export function isInteractionNeededEvent(event: ChatChangeEvent): event is ChatInteractionNeededEvent {
         return event.kind === 'interactionNeeded';
     }
+    export function isStatusChangedEvent(event: ChatChangeEvent): event is ChatSessionStatusChangedEvent {
+        return event.kind === 'statusChanged';
+    }
 }
 
 export type ChatRequestRemovalReason = 'removal' | 'resend' | 'adoption';
@@ -222,10 +239,18 @@ export interface ChatHierarchyBranchItem<TRequest extends ChatRequestModel = Cha
 }
 
 export interface CommonChatSessionSettings {
+    /**
+     * Language model (or alias) id to use for this session only, overriding the agent's default.
+     * New sessions start without an override and use the agent's configured model. Cleared to
+     * revert to the default.
+     */
+    modelId?: string;
     /** Reasoning configuration for this session; applied to reasoning-capable models. */
     reasoning?: ReasoningSettings;
     /** Per-session tool confirmation timeout in seconds. Overrides the global preference when set. */
     confirmationTimeout?: number;
+    /** Per-session server-side compaction settings; set values win over the per-provider and global settings. */
+    compaction?: CompactionSettings;
 }
 
 export interface ChatSessionSettings {
@@ -243,6 +268,69 @@ export interface ChatSessionSettings {
     [key: string]: unknown;
 }
 
+/**
+ * Aggregated, observable status of a chat session, derived from the state of the session's last request.
+ */
+export type ChatSessionStatus =
+    /** No request is in progress. The last request, if any, completed successfully or was canceled. */
+    | 'idle'
+    /** A request is in progress. */
+    | 'running'
+    /** A tool call requires user confirmation before it can be executed. */
+    | 'awaitingApproval'
+    /** An approved or confirmation-free tool call is still executing. */
+    | 'awaitingToolCall'
+    /** The agent is waiting for user input, e.g. an answer to a structured question. */
+    | 'awaitingInput'
+    /** The last request ended in an error. */
+    | 'failed';
+
+export namespace ChatSessionStatus {
+    /**
+     * Whether a request is in progress in this status, including the states waiting on the user or a tool.
+     */
+    export function isInProgress(status: ChatSessionStatus): boolean {
+        return status !== 'idle' && status !== 'failed';
+    }
+
+    /**
+     * Whether the session is blocked on the user, i.e. a tool approval or another input is required to proceed.
+     */
+    export function requiresUserAction(status: ChatSessionStatus): boolean {
+        return status === 'awaitingApproval' || status === 'awaitingInput';
+    }
+
+    /**
+     * Derives the session status from the state of the given request (usually the session's last request).
+     */
+    export function fromRequest(request: ChatRequestModel | undefined): ChatSessionStatus {
+        if (!request) {
+            return 'idle';
+        }
+        const response = request.response;
+        if (response.isError) {
+            return 'failed';
+        }
+        if (!ChatRequestModel.isInProgress(request)) {
+            return 'idle';
+        }
+        const content = response.response.content;
+        if (content.some(part => ToolCallChatResponseContent.is(part) && part.isAwaitingUserConfirmation)) {
+            return 'awaitingApproval';
+        }
+        // Unresolved non-tool-call interactive parts are structured questions (tool calls are
+        // "unresolved" while merely executing). The waiting-for-input flag additionally covers
+        // inputs without a dedicated content part, e.g. the user-interaction tool's wizard.
+        if (response.isWaitingForInput || content.some(part => !ToolCallChatResponseContent.is(part) && InteractiveContent.is(part) && !part.isResolved)) {
+            return 'awaitingInput';
+        }
+        if (content.some(part => ToolCallChatResponseContent.is(part) && !part.finished)) {
+            return 'awaitingToolCall';
+        }
+        return 'running';
+    }
+}
+
 export interface ChatModel {
     readonly onDidChange: Event<ChatChangeEvent>;
     readonly id: string;
@@ -251,8 +339,15 @@ export interface ChatModel {
     readonly suggestions: readonly ChatSuggestion[];
     readonly settings?: ChatSessionSettings;
     readonly changeSet: ChangeSet;
+    /**
+     * Aggregated status of this session, derived from the state of its last request.
+     * Changes are announced via {@link onDidChange} with a {@link ChatSessionStatusChangedEvent}.
+     */
+    readonly status: ChatSessionStatus;
     /** ID of the root session in the delegation chain. For delegated sessions, this points to the topmost session where task contexts are stored. */
     rootSessionId?: string;
+    /** ID of the immediate parent session that delegated this one. Undefined for top-level sessions. */
+    parentSessionId?: string;
     getRequests(): ChatRequestModel[];
     getBranches(): ChatHierarchyBranch<ChatRequestModel>[];
     isEmpty(): boolean;
@@ -477,6 +572,12 @@ export interface ThinkingContentData {
     signature: string;
 }
 
+export interface CompactionContentData {
+    provider: string;
+    data: unknown;
+    summary?: string;
+}
+
 export interface MarkdownContentData {
     content: string;
 }
@@ -581,6 +682,11 @@ export interface ToolCallChatResponseContent extends Required<ChatResponseConten
     confirmed: Promise<boolean>;
     /** Resolves when the tool call requires user confirmation (show Allow/Deny UI). */
     needsUserConfirmation: Promise<void>;
+    /**
+     * Whether the tool call is currently awaiting the user's confirmation decision, i.e.
+     * {@link requestUserConfirmation} was called and the user has neither confirmed nor denied it yet.
+     */
+    readonly isAwaitingUserConfirmation: boolean;
     whenFinished: Promise<void>;
     /**
      * Provider-specific metadata about the tool call that the language model needs back on
@@ -869,6 +975,18 @@ export namespace ThinkingChatResponseContent {
     }
 }
 
+export interface CompactionChatResponseContent extends ChatResponseContent {
+    kind: 'compaction';
+    provider: string;
+    data: unknown;
+    summary?: string;
+}
+export namespace CompactionChatResponseContent {
+    export function is(obj: unknown): obj is CompactionChatResponseContent {
+        return ChatResponseContent.is(obj) && obj.kind === 'compaction';
+    }
+}
+
 export namespace ProgressChatResponseContent {
     export function is(obj: unknown): obj is ProgressChatResponseContent {
         return (
@@ -1008,6 +1126,10 @@ export interface ChatResponseModel {
      * Indicates whether the prompt variant was customized/edited
      */
     readonly isPromptVariantEdited?: boolean;
+    /**
+     * The identifier of the language model that produced this response, if recorded.
+     */
+    readonly languageModel?: string;
     readonly tokenUsage?: ResponseTokenUsage;
     toSerializable(): SerializableChatResponseData;
 }
@@ -1029,7 +1151,9 @@ export class MutableChatModel implements ChatModel, Disposable {
     protected _changeSet: ChatTreeChangeSet;
     protected _settings: ChatSessionSettings;
     protected _location: ChatAgentLocation;
+    protected _status: ChatSessionStatus = 'idle';
     rootSessionId?: string;
+    parentSessionId?: string;
 
     get location(): ChatAgentLocation {
         return this._location;
@@ -1060,7 +1184,14 @@ export class MutableChatModel implements ChatModel, Disposable {
                     branch: event.branch,
                 });
             }),
+            // Re-derive the aggregated session status whenever anything in the model changes.
+            this.onDidChange(event => {
+                if (!ChatChangeEvent.isStatusChangedEvent(event)) {
+                    this.updateStatus();
+                }
+            }),
         ]);
+        this._status = this.computeStatus();
     }
 
     /**
@@ -1097,6 +1228,12 @@ export class MutableChatModel implements ChatModel, Disposable {
             }, this, this.toDispose);
         }
 
+        // Restore per-session settings (e.g. the per-session model override) so the chat input can
+        // reflect the previous selection.
+        if (data.settings) {
+            this._settings = data.settings;
+        }
+
         // Restore the hierarchy structure with all alternatives
         this._hierarchy = new ChatRequestHierarchyImpl<MutableChatRequestModel>(data.hierarchy, requestMap);
 
@@ -1138,6 +1275,22 @@ export class MutableChatModel implements ChatModel, Disposable {
         return this._suggestions;
     }
 
+    get status(): ChatSessionStatus {
+        return this._status;
+    }
+
+    protected computeStatus(): ChatSessionStatus {
+        return ChatSessionStatus.fromRequest(this.getRequests().at(-1));
+    }
+
+    protected updateStatus(): void {
+        const status = this.computeStatus();
+        if (status !== this._status) {
+            this._status = status;
+            this._onDidChangeEmitter.fire({ kind: 'statusChanged', status });
+        }
+    }
+
     get context(): ChatContextManager {
         return this._contextManager;
     }
@@ -1148,6 +1301,9 @@ export class MutableChatModel implements ChatModel, Disposable {
 
     setSettings(settings: ChatSessionSettings): void {
         this._settings = settings;
+        // Emit a change so listeners (e.g. session auto-save) persist selector-only or dialog-only
+        // settings updates that are not accompanied by another model change.
+        this._onDidChangeEmitter.fire({ kind: 'settingsChanged', settings });
     }
 
     addChildModel(child: MutableChatModel): Disposable {
@@ -1219,7 +1375,8 @@ export class MutableChatModel implements ChatModel, Disposable {
             location: this.location,
             hierarchy,
             requests: serializedRequests,
-            responses: serializedResponses
+            responses: serializedResponses,
+            settings: this._settings
         };
     }
 
@@ -2242,6 +2399,58 @@ export class ThinkingChatResponseContentImpl implements ThinkingChatResponseCont
     }
 }
 
+export class CompactionChatResponseContentImpl implements CompactionChatResponseContent {
+    readonly kind = 'compaction';
+    protected _provider: string;
+    protected _data: unknown;
+    protected _summary?: string;
+
+    constructor(provider: string, data: unknown, summary?: string) {
+        this._provider = provider;
+        this._data = data;
+        this._summary = summary;
+    }
+
+    get provider(): string {
+        return this._provider;
+    }
+    get data(): unknown {
+        return this._data;
+    }
+    get summary(): string | undefined {
+        return this._summary;
+    }
+
+    asString(): string | undefined {
+        return undefined;
+    }
+
+    asDisplayString(): string | undefined {
+        return this._summary;
+    }
+
+    toLanguageModelMessage(): CompactionMessage {
+        return {
+            actor: 'ai',
+            type: 'compaction',
+            provider: this._provider,
+            data: this._data,
+            summary: this._summary
+        };
+    }
+
+    toSerializable(): SerializableChatResponseContentData<CompactionContentData> {
+        return {
+            kind: 'compaction',
+            data: {
+                provider: this._provider,
+                data: this._data,
+                summary: this._summary
+            }
+        };
+    }
+}
+
 export class MarkdownChatResponseContentImpl implements MarkdownChatResponseContent {
     readonly kind = 'markdownContent';
     protected _content: MarkdownStringImpl = new MarkdownStringImpl();
@@ -2368,6 +2577,7 @@ export class ToolCallChatResponseContentImpl implements ToolCallChatResponseCont
     protected _confirmationTimeout?: number;
     protected _needsUserConfirmation: Promise<void>;
     protected _needsUserConfirmationResolver?: () => void;
+    protected _isAwaitingUserConfirmation = false;
     protected _confirmed: Promise<boolean>;
     protected _confirmationResolver?: (value: boolean) => void;
     protected _confirmationRejecter?: (reason?: unknown) => void;
@@ -2445,6 +2655,10 @@ export class ToolCallChatResponseContentImpl implements ToolCallChatResponseCont
         return this._needsUserConfirmation;
     }
 
+    get isAwaitingUserConfirmation(): boolean {
+        return this._isAwaitingUserConfirmation && !this.finished;
+    }
+
     get whenFinished(): Promise<void> {
         return this._whenFinished;
     }
@@ -2479,12 +2693,14 @@ export class ToolCallChatResponseContentImpl implements ToolCallChatResponseCont
      * Confirm the tool execution
      */
     confirm(): void {
+        this._isAwaitingUserConfirmation = false;
         if (this._confirmationResolver) {
             this._confirmationResolver(true);
         }
     }
 
     deny(reason?: string): void {
+        this._isAwaitingUserConfirmation = false;
         if (this._confirmationResolver) {
             this._finished = true;
             this._result = { denied: true, reason };
@@ -2494,6 +2710,7 @@ export class ToolCallChatResponseContentImpl implements ToolCallChatResponseCont
     }
 
     requestUserConfirmation(): void {
+        this._isAwaitingUserConfirmation = true;
         if (this._needsUserConfirmationResolver) {
             this._needsUserConfirmationResolver();
             this._needsUserConfirmationResolver = undefined;
@@ -2506,6 +2723,7 @@ export class ToolCallChatResponseContentImpl implements ToolCallChatResponseCont
     }
 
     cancelConfirmation(reason?: unknown): void {
+        this._isAwaitingUserConfirmation = false;
         if (this._confirmationRejecter) {
             this._confirmationRejecter(reason);
         }
@@ -3084,6 +3302,7 @@ export class MutableChatResponseModel implements ChatResponseModel {
     protected _cancellationToken: CancellationTokenSource;
     protected _promptVariantId?: string;
     protected _isPromptVariantEdited?: boolean;
+    protected _languageModel?: string;
     protected _tokenUsage?: ResponseTokenUsage;
     protected _tokenUsageEntries: ResponseTokenUsage[] = [];
 
@@ -3129,6 +3348,7 @@ export class MutableChatResponseModel implements ChatResponseModel {
         this._progressMessages = [];
         this._promptVariantId = data.promptVariantId;
         this._isPromptVariantEdited = data.isPromptVariantEdited ?? false;
+        this._languageModel = data.languageModel;
         this._tokenUsage = data.tokenUsage;
 
         if (data.errorMessage) {
@@ -3209,6 +3429,10 @@ export class MutableChatResponseModel implements ChatResponseModel {
         return this._isPromptVariantEdited ?? false;
     }
 
+    get languageModel(): string | undefined {
+        return this._languageModel;
+    }
+
     get tokenUsage(): ResponseTokenUsage | undefined {
         return this._tokenUsage;
     }
@@ -3233,6 +3457,12 @@ export class MutableChatResponseModel implements ChatResponseModel {
         this._onDidChangeEmitter.fire();
     }
 
+    /** Records the identifier of the language model that produced this response. */
+    setLanguageModel(languageModel: string | undefined): void {
+        this._languageModel = languageModel;
+        this._onDidChangeEmitter.fire();
+    }
+
     overrideAgentId(agentId: string): void {
         this._agentId = agentId;
     }
@@ -3310,6 +3540,7 @@ export class MutableChatResponseModel implements ChatResponseModel {
             errorMessage: this.errorObject?.message,
             promptVariantId: this._promptVariantId,
             isPromptVariantEdited: this._isPromptVariantEdited,
+            languageModel: this._languageModel,
             tokenUsage: this._tokenUsage,
             content: this.response.content.map(c => {
                 const serialized = c.toSerializable?.();

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

@@ -20,7 +20,7 @@ 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';
@@ -276,6 +276,74 @@ 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('uses known command names to disambiguate slash command arguments', async () => {
+        const promptService = {
+            getCommands: () => [
+                { id: 'command-skill-one', template: '', isCommand: true, commandName: 'skill-one' },
+                { id: 'command-skill-two', template: '', isCommand: true, commandName: 'skill-two' },
+            ]
+        } as unknown as PromptService;
+        const parserWithPromptService = new ChatRequestParserImpl(chatAgentService, variableService, toolInvocationRegistry, logger);
+        (parserWithPromptService as unknown as { promptService: PromptService }).promptService = promptService;
+        const context: ChatContext = { variables: [] };
+
+        const multipleCommands = await parserWithPromptService.parseChatRequest({ text: '/skill-one /skill-two' }, ChatAgentLocation.Panel, context);
+        expect((multipleCommands.parts[0] as ParsedChatRequestVariablePart).variableArg).to.equal('skill-one');
+        expect((multipleCommands.parts[2] as ParsedChatRequestVariablePart).variableArg).to.equal('skill-two');
+
+        const pathArgument = await parserWithPromptService.parseChatRequest({ text: '/skill-one /tmp' }, ChatAgentLocation.Panel, context);
+        expect(pathArgument.parts.length).to.equal(1);
+        expect((pathArgument.parts[0] as ParsedChatRequestVariablePart).variableArg).to.equal('skill-one|/tmp');
+    });
+
     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,