@codingame/monaco-vscode-chat-service-override 26.2.2 → 28.0.0

package/vscode/src/vs/workbench/contrib/chat/common/chatDebugService.d.ts

@@ -0,0 +1,190 @@
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
+/**
+ * The severity level of a chat debug log event.
+ */
+export declare enum ChatDebugLogLevel {
+    Trace = 0,
+    Info = 1,
+    Warning = 2,
+    Error = 3
+}
+/**
+ * Common properties shared by all chat debug event types.
+ */
+export interface IChatDebugEventCommon {
+    readonly id?: string;
+    readonly sessionResource: URI;
+    readonly created: Date;
+    readonly parentEventId?: string;
+}
+/**
+ * A tool call event in the chat debug log.
+ */
+export interface IChatDebugToolCallEvent extends IChatDebugEventCommon {
+    readonly kind: "toolCall";
+    readonly toolName: string;
+    readonly toolCallId?: string;
+    readonly input?: string;
+    readonly output?: string;
+    readonly result?: "success" | "error";
+    readonly durationInMillis?: number;
+}
+/**
+ * A model turn event representing an LLM request/response.
+ */
+export interface IChatDebugModelTurnEvent extends IChatDebugEventCommon {
+    readonly kind: "modelTurn";
+    readonly model?: string;
+    readonly requestName?: string;
+    readonly inputTokens?: number;
+    readonly outputTokens?: number;
+    readonly totalTokens?: number;
+    readonly durationInMillis?: number;
+}
+/**
+ * A generic log event for unstructured or miscellaneous messages.
+ */
+export interface IChatDebugGenericEvent extends IChatDebugEventCommon {
+    readonly kind: "generic";
+    readonly name: string;
+    readonly details?: string;
+    readonly level: ChatDebugLogLevel;
+    readonly category?: string;
+}
+/**
+ * A subagent invocation event, representing a spawned sub-agent within a session.
+ */
+export interface IChatDebugSubagentInvocationEvent extends IChatDebugEventCommon {
+    readonly kind: "subagentInvocation";
+    readonly agentName: string;
+    readonly description?: string;
+    readonly status?: "running" | "completed" | "failed";
+    readonly durationInMillis?: number;
+    readonly toolCallCount?: number;
+    readonly modelTurnCount?: number;
+}
+/**
+ * A named section within a user message or agent response.
+ */
+export interface IChatDebugMessageSection {
+    readonly name: string;
+    readonly content: string;
+}
+/**
+ * A user message event, representing the full prompt sent by the user.
+ */
+export interface IChatDebugUserMessageEvent extends IChatDebugEventCommon {
+    readonly kind: "userMessage";
+    readonly message: string;
+    readonly sections: readonly IChatDebugMessageSection[];
+}
+/**
+ * An agent response event, representing the agent's response.
+ */
+export interface IChatDebugAgentResponseEvent extends IChatDebugEventCommon {
+    readonly kind: "agentResponse";
+    readonly message: string;
+    readonly sections: readonly IChatDebugMessageSection[];
+}
+/**
+ * Union of all internal chat debug event types.
+ */
+export type IChatDebugEvent = IChatDebugToolCallEvent | IChatDebugModelTurnEvent | IChatDebugGenericEvent | IChatDebugSubagentInvocationEvent | IChatDebugUserMessageEvent | IChatDebugAgentResponseEvent;
+/**
+ * Plain text content for a resolved debug event.
+ */
+export interface IChatDebugEventTextContent {
+    readonly kind: "text";
+    readonly value: string;
+}
+/**
+ * The status of a file in a file list content.
+ */
+export type ChatDebugFileStatus = "loaded" | "skipped";
+/**
+ * A single file entry in a file list content.
+ */
+export interface IChatDebugFileEntry {
+    readonly uri: URI;
+    readonly name?: string;
+    readonly status: ChatDebugFileStatus;
+    readonly storage?: string;
+    readonly extensionId?: string;
+    readonly skipReason?: string;
+    readonly errorMessage?: string;
+    readonly duplicateOf?: URI;
+}
+/**
+ * A source folder entry in a file list content.
+ */
+export interface IChatDebugSourceFolderEntry {
+    readonly uri: URI;
+    readonly storage: string;
+    readonly exists: boolean;
+    readonly fileCount: number;
+    readonly errorMessage?: string;
+}
+/**
+ * Structured file list content for a resolved debug event.
+ * Contains resolved files and skipped/failed paths for rich rendering.
+ */
+export interface IChatDebugEventFileListContent {
+    readonly kind: "fileList";
+    readonly discoveryType: string;
+    readonly files: readonly IChatDebugFileEntry[];
+    readonly sourceFolders?: readonly IChatDebugSourceFolderEntry[];
+}
+/**
+ * Structured message content for a resolved debug event,
+ * containing collapsible sections.
+ */
+export interface IChatDebugEventMessageContent {
+    readonly kind: "message";
+    readonly type: "user" | "agent";
+    readonly message: string;
+    readonly sections: readonly IChatDebugMessageSection[];
+}
+/**
+ * Structured tool call content for a resolved debug event.
+ * Contains the tool name, status, arguments, and output for rich rendering.
+ */
+export interface IChatDebugEventToolCallContent {
+    readonly kind: "toolCall";
+    readonly toolName: string;
+    readonly result?: "success" | "error";
+    readonly durationInMillis?: number;
+    readonly input?: string;
+    readonly output?: string;
+}
+/**
+ * Structured model turn content for a resolved debug event.
+ * Contains request metadata, token usage, and timing for rich rendering.
+ */
+export interface IChatDebugEventModelTurnContent {
+    readonly kind: "modelTurn";
+    readonly requestName: string;
+    readonly model?: string;
+    readonly status?: string;
+    readonly durationInMillis?: number;
+    readonly timeToFirstTokenInMillis?: number;
+    readonly maxInputTokens?: number;
+    readonly maxOutputTokens?: number;
+    readonly inputTokens?: number;
+    readonly outputTokens?: number;
+    readonly cachedTokens?: number;
+    readonly totalTokens?: number;
+    readonly errorMessage?: string;
+    readonly sections?: readonly IChatDebugMessageSection[];
+}
+/**
+ * Union of all resolved event content types.
+ */
+export type IChatDebugResolvedEventContent = IChatDebugEventTextContent | IChatDebugEventFileListContent | IChatDebugEventMessageContent | IChatDebugEventToolCallContent | IChatDebugEventModelTurnContent;
+/**
+ * Provider interface for debug events.
+ */
+export interface IChatDebugLogProvider {
+    provideChatDebugLog(sessionResource: URI, token: CancellationToken): Promise<IChatDebugEvent[] | undefined>;
+    resolveChatDebugLogEvent?(eventId: string, token: CancellationToken): Promise<IChatDebugResolvedEventContent | undefined>;
+}

package/vscode/src/vs/workbench/contrib/chat/common/chatDebugService.js

@@ -0,0 +1,11 @@
+
+
+var ChatDebugLogLevel;
+(function (ChatDebugLogLevel) {
+    ChatDebugLogLevel[ChatDebugLogLevel["Trace"] = 0] = "Trace";
+    ChatDebugLogLevel[ChatDebugLogLevel["Info"] = 1] = "Info";
+    ChatDebugLogLevel[ChatDebugLogLevel["Warning"] = 2] = "Warning";
+    ChatDebugLogLevel[ChatDebugLogLevel["Error"] = 3] = "Error";
+})(ChatDebugLogLevel || (ChatDebugLogLevel = {}));
+
+export { ChatDebugLogLevel };

package/vscode/src/vs/workbench/contrib/chat/common/chatDebugServiceImpl.d.ts

@@ -0,0 +1,44 @@
+import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
+import { Disposable, IDisposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { ChatDebugLogLevel, IChatDebugEvent, IChatDebugLogProvider, IChatDebugResolvedEventContent } from "./chatDebugService.js";
+import { IChatDebugService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatDebugService.service";
+export declare class ChatDebugServiceImpl extends Disposable implements IChatDebugService {
+    readonly _serviceBrand: undefined;
+    private static readonly MAX_EVENTS;
+    private readonly _buffer;
+    private _head;
+    private _size;
+    private readonly _onDidAddEvent;
+    readonly onDidAddEvent: Event<IChatDebugEvent>;
+    private readonly _onDidClearProviderEvents;
+    readonly onDidClearProviderEvents: Event<URI>;
+    private readonly _onDidAttachDebugData;
+    readonly onDidAttachDebugData: Event<URI>;
+    private readonly _debugDataAttachedSessions;
+    private readonly _providers;
+    private readonly _invocationCts;
+    /** Events that were returned by providers (not internally logged). */
+    private readonly _providerEvents;
+    activeSessionResource: URI | undefined;
+    log(sessionResource: URI, name: string, details?: string, level?: ChatDebugLogLevel, options?: {
+        id?: string;
+        category?: string;
+        parentEventId?: string;
+    }): void;
+    addEvent(event: IChatDebugEvent): void;
+    addProviderEvent(event: IChatDebugEvent): void;
+    getEvents(sessionResource?: URI): readonly IChatDebugEvent[];
+    getSessionResources(): readonly URI[];
+    clear(): void;
+    registerProvider(provider: IChatDebugLogProvider): IDisposable;
+    hasInvokedProviders(sessionResource: URI): boolean;
+    invokeProviders(sessionResource: URI): Promise<void>;
+    private _invokeProvider;
+    endSession(sessionResource: URI): void;
+    private _clearProviderEvents;
+    markDebugDataAttached(sessionResource: URI): void;
+    hasAttachedDebugData(sessionResource: URI): boolean;
+    resolveEvent(eventId: string): Promise<IChatDebugResolvedEventContent | undefined>;
+    dispose(): void;
+}

package/vscode/src/vs/workbench/contrib/chat/common/chatDebugServiceImpl.js

@@ -0,0 +1,208 @@
+
+import { CancellationTokenSource, CancellationToken } from '@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation';
+import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { onUnexpectedError } from '@codingame/monaco-vscode-api/vscode/vs/base/common/errors';
+import { Disposable, toDisposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { ResourceMap } from '@codingame/monaco-vscode-api/vscode/vs/base/common/map';
+import { ChatDebugLogLevel } from './chatDebugService.js';
+import { LocalChatSessionUri } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatUri';
+
+class ChatDebugServiceImpl extends Disposable {
+    constructor() {
+        super(...arguments);
+        this._buffer = ( new Array(ChatDebugServiceImpl.MAX_EVENTS));
+        this._head = 0;
+        this._size = 0;
+        this._onDidAddEvent = this._register(( new Emitter()));
+        this.onDidAddEvent = this._onDidAddEvent.event;
+        this._onDidClearProviderEvents = this._register(( new Emitter()));
+        this.onDidClearProviderEvents = this._onDidClearProviderEvents.event;
+        this._onDidAttachDebugData = this._register(( new Emitter()));
+        this.onDidAttachDebugData = this._onDidAttachDebugData.event;
+        this._debugDataAttachedSessions = ( new ResourceMap());
+        this._providers = ( new Set());
+        this._invocationCts = ( new ResourceMap());
+        this._providerEvents = ( new WeakSet());
+    }
+    static {
+        this.MAX_EVENTS = 10_000;
+    }
+    log(sessionResource, name, details, level = ChatDebugLogLevel.Info, options) {
+        if (!LocalChatSessionUri.isLocalSession(sessionResource)) {
+            return;
+        }
+        this.addEvent({
+            kind: "generic",
+            id: options?.id,
+            sessionResource,
+            created: ( new Date()),
+            name,
+            details,
+            level,
+            category: options?.category,
+            parentEventId: options?.parentEventId
+        });
+    }
+    addEvent(event) {
+        const idx = (this._head + this._size) % ChatDebugServiceImpl.MAX_EVENTS;
+        this._buffer[idx] = event;
+        if (this._size < ChatDebugServiceImpl.MAX_EVENTS) {
+            this._size++;
+        } else {
+            this._head = (this._head + 1) % ChatDebugServiceImpl.MAX_EVENTS;
+        }
+        this._onDidAddEvent.fire(event);
+    }
+    addProviderEvent(event) {
+        this._providerEvents.add(event);
+        this.addEvent(event);
+    }
+    getEvents(sessionResource) {
+        const result = [];
+        const key = sessionResource?.toString();
+        for (let i = 0; i < this._size; i++) {
+            const event = this._buffer[(this._head + i) % ChatDebugServiceImpl.MAX_EVENTS];
+            if (!event) {
+                continue;
+            }
+            if (!key || ( event.sessionResource.toString()) === key) {
+                result.push(event);
+            }
+        }
+        result.sort((a, b) => a.created.getTime() - b.created.getTime());
+        return result;
+    }
+    getSessionResources() {
+        const seen = ( new ResourceMap());
+        const result = [];
+        for (let i = 0; i < this._size; i++) {
+            const event = this._buffer[(this._head + i) % ChatDebugServiceImpl.MAX_EVENTS];
+            if (!event) {
+                continue;
+            }
+            if (!( seen.has(event.sessionResource))) {
+                seen.set(event.sessionResource, true);
+                result.push(event.sessionResource);
+            }
+        }
+        return result;
+    }
+    clear() {
+        this._buffer.fill(undefined);
+        this._head = 0;
+        this._size = 0;
+        this._debugDataAttachedSessions.clear();
+    }
+    registerProvider(provider) {
+        this._providers.add(provider);
+        for (const [sessionResource, cts] of this._invocationCts) {
+            if (!cts.token.isCancellationRequested) {
+                this._invokeProvider(provider, sessionResource, cts.token).catch(onUnexpectedError);
+            }
+        }
+        return toDisposable(() => {
+            this._providers.delete(provider);
+        });
+    }
+    hasInvokedProviders(sessionResource) {
+        return ( this._invocationCts.has(sessionResource));
+    }
+    async invokeProviders(sessionResource) {
+        if (!LocalChatSessionUri.isLocalSession(sessionResource)) {
+            return;
+        }
+        const existingCts = this._invocationCts.get(sessionResource);
+        if (existingCts) {
+            existingCts.cancel();
+            existingCts.dispose();
+        }
+        this._clearProviderEvents(sessionResource);
+        const cts = ( new CancellationTokenSource());
+        this._invocationCts.set(sessionResource, cts);
+        try {
+            const promises = ( [...this._providers].map(provider => this._invokeProvider(provider, sessionResource, cts.token)));
+            await Promise.allSettled(promises);
+        } catch (err) {
+            onUnexpectedError(err);
+        }
+    }
+    async _invokeProvider(provider, sessionResource, token) {
+        try {
+            const events = await provider.provideChatDebugLog(sessionResource, token);
+            if (events) {
+                for (const event of events) {
+                    this.addProviderEvent({
+                        ...event,
+                        sessionResource: event.sessionResource ?? sessionResource
+                    });
+                }
+            }
+        } catch (err) {
+            onUnexpectedError(err);
+        }
+    }
+    endSession(sessionResource) {
+        const cts = this._invocationCts.get(sessionResource);
+        if (cts) {
+            cts.cancel();
+            cts.dispose();
+            this._invocationCts.delete(sessionResource);
+        }
+        this._debugDataAttachedSessions.delete(sessionResource);
+    }
+    _clearProviderEvents(sessionResource) {
+        const key = ( sessionResource.toString());
+        let write = 0;
+        for (let i = 0; i < this._size; i++) {
+            const idx = (this._head + i) % ChatDebugServiceImpl.MAX_EVENTS;
+            const event = this._buffer[idx];
+            if (event && ( this._providerEvents.has(event)) && ( event.sessionResource.toString()) === key) {
+                continue;
+            }
+            if (write !== i) {
+                const writeIdx = (this._head + write) % ChatDebugServiceImpl.MAX_EVENTS;
+                this._buffer[writeIdx] = event;
+            }
+            write++;
+        }
+        for (let i = write; i < this._size; i++) {
+            this._buffer[(this._head + i) % ChatDebugServiceImpl.MAX_EVENTS] = undefined;
+        }
+        this._size = write;
+        this._onDidClearProviderEvents.fire(sessionResource);
+    }
+    markDebugDataAttached(sessionResource) {
+        if (!( this._debugDataAttachedSessions.has(sessionResource))) {
+            this._debugDataAttachedSessions.set(sessionResource, true);
+            this._onDidAttachDebugData.fire(sessionResource);
+        }
+    }
+    hasAttachedDebugData(sessionResource) {
+        return ( this._debugDataAttachedSessions.has(sessionResource));
+    }
+    async resolveEvent(eventId) {
+        for (const provider of this._providers) {
+            if (provider.resolveChatDebugLogEvent) {
+                try {
+                    const resolved = await provider.resolveChatDebugLogEvent(eventId, CancellationToken.None);
+                    if (resolved !== undefined) {
+                        return resolved;
+                    }
+                } catch (err) {
+                    onUnexpectedError(err);
+                }
+            }
+        }
+        return undefined;
+    }
+    dispose() {
+        for (const cts of ( this._invocationCts.values())) {
+            cts.cancel();
+            cts.dispose();
+        }
+        this._invocationCts.clear();
+        super.dispose();
+    }
+}
+
+export { ChatDebugServiceImpl };

package/vscode/src/vs/workbench/contrib/chat/common/chatService/chatServiceImpl.d.ts

@@ -7,8 +7,11 @@ import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/pl
 import { IInstantiationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation";
 import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
 import { IStorageService } from "@codingame/monaco-vscode-api/vscode/vs/platform/storage/common/storage.service";
+import { ITelemetryService } from "@codingame/monaco-vscode-api/vscode/vs/platform/telemetry/common/telemetry.service";
 import { IWorkspaceContextService } from "@codingame/monaco-vscode-api/vscode/vs/platform/workspace/common/workspace.service";
 import { IExtensionService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extensions.service";
+import { IChatEntitlementService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/chat/common/chatEntitlementService.service";
+import { IChatDebugService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatDebugService.service";
 import { IMcpService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/mcp/common/mcpTypes.service";
 import { IChatAgentService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/participants/chatAgents.service";
 import { ChatModel, IChatModel, IChatRequestModel, IChatRequestVariableData, IExportableChatData, ISerializableChatData } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatModel";
@@ -19,10 +22,12 @@ import { IChatSessionsService } from "@codingame/monaco-vscode-api/vscode/vs/wor
 import { IChatSlashCommandService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/participants/chatSlashCommands.service";
 import { IChatTransferService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatTransferService.service";
 import { ChatAgentLocation } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/constants";
+import { ILanguageModelsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/languageModels.service";
 import { IPromptsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/service/promptsService.service";
 export declare class ChatService extends Disposable implements IChatService {
     private readonly storageService;
     private readonly logService;
+    private readonly telemetryService;
     private readonly extensionService;
     private readonly instantiationService;
     private readonly workspaceContextService;
@@ -33,6 +38,9 @@ export declare class ChatService extends Disposable implements IChatService {
     private readonly chatSessionService;
     private readonly mcpService;
     private readonly promptsService;
+    private readonly chatEntitlementService;
+    private readonly languageModelsService;
+    private readonly chatDebugService;
     _serviceBrand: undefined;
     private readonly _sessionModels;
     private readonly _pendingRequests;
@@ -43,6 +51,7 @@ export declare class ChatService extends Disposable implements IChatService {
     private readonly _onDidSubmitRequest;
     readonly onDidSubmitRequest: Event<{
         readonly chatSessionResource: URI;
+        readonly message?: IParsedChatRequest;
     }>;
     get onDidCreateModel(): Event<ChatModel>;
     private readonly _onDidPerformUserAction;
@@ -71,9 +80,8 @@ export declare class ChatService extends Disposable implements IChatService {
      * For test use only
      */
     waitForModelDisposals(): Promise<void>;
-    get edits2Enabled(): boolean;
     private get isEmptyWindow();
-    constructor(storageService: IStorageService, logService: ILogService, extensionService: IExtensionService, instantiationService: IInstantiationService, workspaceContextService: IWorkspaceContextService, chatSlashCommandService: IChatSlashCommandService, chatAgentService: IChatAgentService, configurationService: IConfigurationService, chatTransferService: IChatTransferService, chatSessionService: IChatSessionsService, mcpService: IMcpService, promptsService: IPromptsService);
+    constructor(storageService: IStorageService, logService: ILogService, telemetryService: ITelemetryService, extensionService: IExtensionService, instantiationService: IInstantiationService, workspaceContextService: IWorkspaceContextService, chatSlashCommandService: IChatSlashCommandService, chatAgentService: IChatAgentService, configurationService: IConfigurationService, chatTransferService: IChatTransferService, chatSessionService: IChatSessionsService, mcpService: IMcpService, promptsService: IPromptsService, chatEntitlementService: IChatEntitlementService, languageModelsService: ILanguageModelsService, chatDebugService: IChatDebugService);
     get editingSessions(): import("@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/editing/chatEditingService").IChatEditingSession[];
     isEnabled(location: ChatAgentLocation): boolean;
     private migrateData;
@@ -113,16 +121,17 @@ export declare class ChatService extends Disposable implements IChatService {
     private shouldBeInHistory;
     removeHistoryEntry(sessionResource: URI): Promise<void>;
     clearAllHistoryEntries(): Promise<void>;
-    startSession(location: ChatAgentLocation, options?: IChatSessionStartOptions): IChatModelReference;
+    startNewLocalSession(location: ChatAgentLocation, options?: IChatSessionStartOptions): IChatModelReference;
     private _startSession;
     private initializeSession;
     activateDefaultAgent(location: ChatAgentLocation): Promise<void>;
     getSession(sessionResource: URI): IChatModel | undefined;
-    getActiveSessionReference(sessionResource: URI): IChatModelReference | undefined;
-    getOrRestoreSession(sessionResource: URI): Promise<IChatModelReference | undefined>;
+    acquireExistingSession(sessionResource: URI): IChatModelReference | undefined;
+    private acquireOrRestoreLocalSession;
     getSessionTitle(sessionResource: URI): string | undefined;
-    loadSessionFromContent(data: IExportableChatData | ISerializableChatData): IChatModelReference | undefined;
-    loadSessionForResource(chatSessionResource: URI, location: ChatAgentLocation, token: CancellationToken): Promise<IChatModelReference | undefined>;
+    loadSessionFromData(data: IExportableChatData | ISerializableChatData): IChatModelReference;
+    acquireOrLoadSession(sessionResource: URI, location: ChatAgentLocation, token: CancellationToken): Promise<IChatModelReference | undefined>;
+    private loadRemoteSession;
     getChatSessionFromInternalUri(sessionResource: URI): IChatSessionContext | undefined;
     resendRequest(request: IChatRequestModel, options?: IChatSendRequestOptions): Promise<void>;
     private queuePendingRequest;
@@ -134,6 +143,7 @@ export declare class ChatService extends Disposable implements IChatService {
     /**
      * Process the next pending request from the model's queue, if any.
      * Called after a request completes to continue processing queued requests.
+     * Multiple consecutive steering requests are combined into a single request.
      */
     private processNextPendingRequest;
     private generateInitialChatTitleIfNeeded;
@@ -142,7 +152,7 @@ export declare class ChatService extends Disposable implements IChatService {
     removeRequest(sessionResource: URI, requestId: string): Promise<void>;
     adoptRequest(sessionResource: URI, request: IChatRequestModel): Promise<void>;
     addCompleteRequest(sessionResource: URI, message: IParsedChatRequest | string, variableData: IChatRequestVariableData | undefined, attempt: number | undefined, response: IChatCompleteResponse): Promise<void>;
-    cancelCurrentRequestForSession(sessionResource: URI): void;
+    cancelCurrentRequestForSession(sessionResource: URI, source?: string): void;
     setYieldRequested(sessionResource: URI): void;
     removePendingRequest(sessionResource: URI, requestId: string): void;
     setPendingRequests(sessionResource: URI, requests: readonly {
@@ -153,7 +163,7 @@ export declare class ChatService extends Disposable implements IChatService {
     transferChatSession(transferredSessionResource: URI, toWorkspace: URI): Promise<void>;
     getChatStorageFolder(): URI;
     logChatIndex(): void;
-    setTitle(sessionResource: URI, title: string): void;
+    setSessionTitle(sessionResource: URI, title: string): void;
     appendProgress(request: IChatRequestModel, progress: IChatProgress): void;
     private toLocalSessionId;
 }