@codingame/monaco-vscode-chat-service-override 34.1.2 → 35.0.0

package/vscode/src/vs/workbench/contrib/chat/browser/widgetHosts/viewPane/media/chatViewPane.css

@@ -3,11 +3,88 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
+/* Voice Agent Bar — wraps the shared AgentsVoiceWidget inside input container */
+.voice-agent-bar {
+	display: flex;
+	flex-direction: column;
+	flex-shrink: 0;
+	border-bottom: 1px solid var(--vscode-panel-border);
+	position: relative;
+	overflow: hidden;
+}
+
+@keyframes voiceTextPulse {
+	0%,
+	100% {
+		opacity: 0.9;
+	}
+
+	50% {
+		opacity: 0.4;
+	}
+}
+
+.voice-transcript-overlay-scrollable {
+	position: absolute !important;
+	top: 0;
+	left: 0;
+	right: 0;
+	bottom: 36px;
+	z-index: 10;
+	/* Let clicks pass through to the input editor unless there is scrollable transcript content */
+	pointer-events: none;
+	background: var(--vscode-input-background, transparent);
+	border-radius: inherit;
+	border-bottom-left-radius: 0;
+	border-bottom-right-radius: 0;
+}
+
+.voice-transcript-overlay-scrollable.has-transcript {
+	pointer-events: auto;
+}
+
+.voice-transcript-overlay {
+	height: 100%;
+	box-sizing: border-box;
+	padding: var(--vscode-spacing-size80) var(--vscode-spacing-size120);
+	font-size: var(--vscode-bodyFontSize);
+	line-height: 1.4;
+	word-break: break-word;
+	overflow: hidden;
+	overscroll-behavior: contain;
+}
+
+.voice-transcript-overlay .committed {
+	color: var(--vscode-foreground);
+}
+
+.voice-transcript-overlay .partial {
+	color: var(--vscode-foreground);
+	opacity: 0.6;
+	font-style: italic;
+	animation: voiceTextPulse 1.5s ease-in-out infinite;
+}
+
+.voice-transcript-overlay .assistant-text {
+	color: var(--vscode-descriptionForeground);
+	white-space: pre-wrap;
+}
+
 /* Overall styles */
 .chat-viewpane {
 	display: flex;
 	flex-direction: column;
 
+	/* wrapper that holds sessions + chat controls */
+	> .voice-agent-controls-wrapper {
+		display: flex;
+		flex-direction: column;
+		flex: 1;
+		min-height: 0;
+		min-width: 0;
+		overflow: hidden;
+	}
+
 	.chat-controls-container {
 		display: flex;
 		flex-direction: column;
@@ -17,7 +94,7 @@
 		min-width: 0;
 
 		.interactive-session {
-
+			flex: 1;
 			/* needed so that the chat input does not overflow and input grows over content above */
 			width: 100%;
 			min-height: 0;
@@ -38,7 +115,6 @@
 		font-size: 11px;
 		font-weight: 700;
 		text-transform: uppercase;
-		letter-spacing: 0.5px;
 
 		.agent-sessions-title {
 			cursor: pointer;
@@ -83,7 +159,7 @@
 /* Sessions control: side by side */
 .chat-viewpane.has-sessions-control.sessions-control-orientation-sidebyside {
 
-	&.chat-view-position-left {
+	&.chat-view-position-left > .voice-agent-controls-wrapper {
 		flex-direction: row;
 
 		.agent-sessions-container {
@@ -91,7 +167,7 @@
 		}
 	}
 
-	&.chat-view-position-right {
+	&.chat-view-position-right > .voice-agent-controls-wrapper {
 		flex-direction: row-reverse;
 
 		.agent-sessions-container {

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

@@ -0,0 +1,78 @@
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+/**
+ * How often an automation runs. `hourly` fires every hour from creation/update;
+ * `daily`/`weekly` fire at the configured local-time hour/minute (and day-of-week).
+ */
+export type AutomationInterval = "manual" | "hourly" | "daily" | "weekly";
+/**
+ * Describes the cadence at which an automation should fire.
+ *
+ * Times are stored in local-time wall-clock values. The scheduler converts
+ * them to UTC when computing concrete run instants so DST transitions are
+ * handled correctly.
+ */
+export interface IAutomationSchedule {
+    readonly interval: AutomationInterval;
+    /** Hour-of-day, 0-23. Ignored for `manual` and `hourly`. */
+    readonly scheduleHour: number;
+    /** Minute-of-hour, 0-59. Ignored for `manual` and `hourly`. */
+    readonly scheduleMinute: number;
+    /** Day-of-week, 0 (Sunday) through 6 (Saturday). Only used for `weekly`. */
+    readonly scheduleDay: number;
+}
+/**
+ * A single scheduled automation. Identity is the immutable `id`; everything
+ * else may be edited by the user.
+ */
+export interface IAutomation {
+    readonly id: string;
+    readonly name: string;
+    readonly prompt: string;
+    readonly schedule: IAutomationSchedule;
+    /** Workspace folder for the spawned session. Required. */
+    readonly folderUri: URI;
+    /**
+     * Sessions provider for the scheduled run (e.g. `local-agent-host`). Omitted
+     * on automations predating the picker; the runner then falls back to the
+     * workspace default provider.
+     */
+    readonly providerId?: string;
+    /** Session type to create within {@link providerId}, captured alongside it. */
+    readonly sessionTypeId?: string;
+    /** Optional language model identifier to seed the new session with. */
+    readonly modelId?: string;
+    /** Optional chat mode (`agent`/`ask`/`edit`). Defaults to provider's default; custom modes unsupported. */
+    readonly mode?: string;
+    /** Optional permission level (`default`/`autoApprove`/`autopilot`). Overrides only for scheduled runs; defaults to provider's default. */
+    readonly permissionLevel?: string;
+    /** Optional worktree isolation mode (`worktree` or `workspace`). */
+    readonly isolationMode?: string;
+    /** Optional git branch for isolated runs. */
+    readonly branch?: string;
+    readonly enabled: boolean;
+    /** ISO-8601 UTC timestamp. */
+    readonly createdAt: string;
+    readonly updatedAt: string;
+    readonly lastRunAt?: string;
+    /** ISO-8601 UTC timestamp; `undefined` when interval is `manual`. */
+    readonly nextRunAt?: string;
+}
+export type AutomationRunStatus = "pending" | "running" | "completed" | "failed";
+/**
+ * What kicked off a run. `catch_up` fires once at startup for a due-time that
+ * passed while VS Code was closed.
+ */
+export type AutomationRunTrigger = "schedule" | "catch_up" | "manual";
+export interface IAutomationRun {
+    readonly id: string;
+    readonly automationId: string;
+    readonly status: AutomationRunStatus;
+    readonly trigger: AutomationRunTrigger;
+    /** Session resource URI (stringified) assigned by ISessionsManagementService, if any. */
+    readonly sessionResource?: string;
+    readonly startedAt: string;
+    readonly completedAt?: string;
+    readonly errorMessage?: string;
+    /** Window that claimed this run; the leader-election guard uses it to avoid duplicate execution across windows. */
+    readonly leaderWindowId: number;
+}

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

@@ -0,0 +1,13 @@
+import { IAutomation } from "./automation.js";
+import { ICreateAutomationOptions, IUpdateAutomationOptions } from "./automationService.js";
+export interface IShowAutomationDialogOptions {
+    readonly existing?: IAutomation;
+}
+export type IAutomationDialogResult = {
+    readonly kind: "create";
+    readonly value: ICreateAutomationOptions;
+} | {
+    readonly kind: "update";
+    readonly id: string;
+    readonly value: IUpdateAutomationOptions;
+};

package/vscode/src/vs/workbench/contrib/chat/common/automations/automationDialogService.service.d.ts

@@ -0,0 +1,11 @@
+import { IShowAutomationDialogOptions, IAutomationDialogResult } from "./automationDialogService.js";
+export declare const IAutomationDialogService: import("@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation").ServiceIdentifier<IAutomationDialogService>;
+/**
+* Bridges the workbench Automations UI (list widget) to the Sessions-layer
+* dialog implementation without a cross-layer import: the widget depends only
+* on this interface, while {@link AutomationDialogService} (sessions) provides it.
+*/
+export interface IAutomationDialogService {
+    readonly _serviceBrand: undefined;
+    showAutomationDialog(options: IShowAutomationDialogOptions): Promise<IAutomationDialogResult | undefined>;
+}

package/vscode/src/vs/workbench/contrib/chat/common/automations/automationDialogService.service.js

@@ -0,0 +1,6 @@
+
+import { createDecorator } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+
+const IAutomationDialogService = ( createDecorator("automationDialogService"));
+
+export { IAutomationDialogService };

package/vscode/src/vs/workbench/contrib/chat/common/automations/automationRunner.service.d.ts

@@ -0,0 +1,16 @@
+import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
+import { IAutomation, AutomationRunTrigger } from "./automation.js";
+export declare const IAutomationRunner: import("@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation").ServiceIdentifier<IAutomationRunner>;
+/**
+* Runs a single automation: claim the per-automation slot, record the run,
+* drive the chat session, report success/failure to {@link IAutomationService}.
+* Implemented in the sessions layer via `ISessionsManagementService`.
+*/
+export interface IAutomationRunner {
+    readonly _serviceBrand: undefined;
+    /**
+    * Runs `automation` once (skips if another run for it is already in flight).
+    * Never throws. Failures are recorded on the run row in {@link IAutomationService}.
+    */
+    runOnce(automation: IAutomation, trigger: AutomationRunTrigger, leaderWindowId: number, token?: CancellationToken): Promise<void>;
+}

package/vscode/src/vs/workbench/contrib/chat/common/automations/automationRunner.service.js

@@ -0,0 +1,6 @@
+
+import { createDecorator } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+
+const IAutomationRunner = ( createDecorator("automationRunner"));
+
+export { IAutomationRunner };

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

@@ -0,0 +1,46 @@
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { IAutomationRun, IAutomationSchedule } from "./automation.js";
+/**
+ * Input for `createAutomation`. The service fills in `id`, timestamps, and
+ * `nextRunAt`. `folderUri` is required.
+ */
+export interface ICreateAutomationOptions {
+    readonly name: string;
+    readonly prompt: string;
+    readonly schedule: IAutomationSchedule;
+    readonly folderUri: URI;
+    readonly providerId?: string;
+    readonly sessionTypeId?: string;
+    readonly modelId?: string;
+    readonly mode?: string;
+    readonly permissionLevel?: string;
+    readonly isolationMode?: string;
+    readonly branch?: string;
+    readonly enabled?: boolean;
+}
+/**
+ * Patch for `updateAutomation`. Absent fields are unchanged. Pass `null` for
+ * `providerId`/`sessionTypeId`/`modelId`/`mode`/`permissionLevel` to clear them;
+ * `folderUri` cannot be cleared.
+ */
+export interface IUpdateAutomationOptions {
+    readonly name?: string;
+    readonly prompt?: string;
+    readonly schedule?: IAutomationSchedule;
+    readonly folderUri?: URI;
+    readonly providerId?: string | null;
+    readonly sessionTypeId?: string | null;
+    readonly modelId?: string | null;
+    readonly mode?: string | null;
+    readonly permissionLevel?: string | null;
+    readonly isolationMode?: string | null;
+    readonly branch?: string | null;
+    readonly enabled?: boolean;
+}
+/** Patch for `updateRun`. Absent fields are unchanged. */
+export interface IUpdateAutomationRunOptions {
+    readonly status?: IAutomationRun["status"];
+    readonly sessionResource?: string;
+    readonly completedAt?: string;
+    readonly errorMessage?: string;
+}

package/vscode/src/vs/workbench/contrib/chat/common/automations/automationService.service.d.ts

@@ -0,0 +1,36 @@
+import { IObservable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/observable";
+import { IAutomation, IAutomationRun, AutomationRunTrigger } from "./automation.js";
+import { ICreateAutomationOptions, IUpdateAutomationOptions, IUpdateAutomationRunOptions } from "./automationService.js";
+export declare const IAutomationService: import("@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation").ServiceIdentifier<IAutomationService>;
+/**
+* Persistent store for automations and their run history, and the single
+* mutation point. Scheduler, runner, and UI all flow through it to keep
+* cross-window propagation, persistence, and observables consistent.
+*/
+export interface IAutomationService {
+    readonly _serviceBrand: undefined;
+    /** All defined automations, newest first. */
+    readonly automations: IObservable<readonly IAutomation[]>;
+    /** All recorded runs across all automations, newest first. */
+    readonly runs: IObservable<readonly IAutomationRun[]>;
+    /** Snapshot accessor (no observable dependency). */
+    getAutomation(id: string): IAutomation | undefined;
+    /** Runs for a single automation, newest first. */
+    runsFor(automationId: string): IObservable<readonly IAutomationRun[]>;
+    createAutomation(options: ICreateAutomationOptions): Promise<IAutomation>;
+    updateAutomation(id: string, patch: IUpdateAutomationOptions): Promise<IAutomation>;
+    deleteAutomation(id: string): Promise<void>;
+    /** Records a new run as `pending`. Throws if the automation does not exist. */
+    recordRunStart(automationId: string, trigger: AutomationRunTrigger, leaderWindowId: number): Promise<IAutomationRun>;
+    /** Applies a patch to a run; returns the updated run or `undefined` if not found. */
+    updateRun(runId: string, patch: IUpdateAutomationRunOptions): Promise<IAutomationRun | undefined>;
+    /** Most recent `pending`/`running` run for an automation, or `undefined`. Backs the runner's per-automation claim. */
+    getActiveRunFor(automationId: string): IAutomationRun | undefined;
+    /** Marks all stuck (`pending`/`running`) runs failed. Called on startup to recover from crashes. */
+    markStaleRunsFailed(reason: string): Promise<void>;
+    /**
+    * Sets `lastRunAt = now` and recomputes `nextRunAt`. Called right after
+    * dispatch so the same automation isn't picked up twice on the next tick.
+    */
+    advanceNextRunAt(id: string, now?: Date): Promise<IAutomation | undefined>;
+}

package/vscode/src/vs/workbench/contrib/chat/common/automations/automationService.service.js

@@ -0,0 +1,6 @@
+
+import { createDecorator } from '@codingame/monaco-vscode-api/vscode/vs/platform/instantiation/common/instantiation';
+
+const IAutomationService = ( createDecorator("automationService"));
+
+export { IAutomationService };

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

@@ -0,0 +1,12 @@
+import { RawContextKey } from "@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey";
+/**
+ * Gates the entire Automations feature: sidebar entry, editor section,
+ * session composer option, and scheduled execution. Default `false`.
+ */
+export declare const CHAT_AUTOMATIONS_ENABLED_SETTING = "chat.automations.enabled";
+/** Per-run timeout in minutes. Hung runs are cancelled and marked failed so they don't block the dispatch chain. */
+export declare const CHAT_AUTOMATIONS_RUN_TIMEOUT_MINUTES_SETTING = "chat.automations.runTimeoutMinutes";
+/** Default for {@link CHAT_AUTOMATIONS_RUN_TIMEOUT_MINUTES_SETTING}. */
+export declare const DEFAULT_AUTOMATIONS_RUN_TIMEOUT_MINUTES = 30;
+/** Context key mirroring {@link CHAT_AUTOMATIONS_ENABLED_SETTING}, for `when` clauses on menus/commands. */
+export declare const ChatAutomationsEnabledContext: RawContextKey<boolean>;

package/vscode/src/vs/workbench/contrib/chat/common/automations/automationsEnabled.js

@@ -0,0 +1,6 @@
+
+import '@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey';
+
+const CHAT_AUTOMATIONS_ENABLED_SETTING = "chat.automations.enabled";
+
+export { CHAT_AUTOMATIONS_ENABLED_SETTING };

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

@@ -0,0 +1,9 @@
+import { IAutomationSchedule } from "./automation.js";
+export declare const DAYS_OF_WEEK: readonly string[];
+/**
+ * Computes the next fire time for a schedule. Daily/weekly times are
+ * local wall-clock (not UTC) so DST transitions don't shift them.
+ * Day advances use `Date` constructor overflow, not milliseconds, to
+ * avoid skipping spring-forward days. Returns `undefined` for `manual`.
+ */
+export declare function computeNextRunAt(schedule: IAutomationSchedule, now: Date): Date | undefined;

package/vscode/src/vs/workbench/contrib/chat/common/automations/schedule.js

@@ -0,0 +1,6 @@
+
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+
+const DAYS_OF_WEEK = [( localize(8515, "Sunday")), ( localize(8516, "Monday")), ( localize(8517, "Tuesday")), ( localize(8518, "Wednesday")), ( localize(8519, "Thursday")), ( localize(8520, "Friday")), ( localize(8521, "Saturday"))];
+
+export { DAYS_OF_WEEK };

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

@@ -21,6 +21,8 @@ export declare class ChatDebugServiceImpl extends Disposable implements IChatDeb
     readonly onDidAddEvent: Event<IChatDebugEvent>;
     private readonly _onDidClearProviderEvents;
     readonly onDidClearProviderEvents: Event<URI>;
+    private readonly _onDidEndSession;
+    readonly onDidEndSession: Event<URI>;
     private readonly _onDidChangeAvailableSessionResources;
     readonly onDidChangeAvailableSessionResources: Event<void>;
     private readonly _providers;

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

@@ -74,6 +74,8 @@ class ChatDebugServiceImpl extends Disposable {
         this.onDidAddEvent = this._onDidAddEvent.event;
         this._onDidClearProviderEvents = this._register(( new Emitter()));
         this.onDidClearProviderEvents = this._onDidClearProviderEvents.event;
+        this._onDidEndSession = this._register(( new Emitter()));
+        this.onDidEndSession = this._onDidEndSession.event;
         this._onDidChangeAvailableSessionResources = this._register(( new Emitter()));
         this.onDidChangeAvailableSessionResources = this._onDidChangeAvailableSessionResources.event;
         this._providers = ( new Set());
@@ -107,10 +109,13 @@ class ChatDebugServiceImpl extends Disposable {
         this._debugEligibleSessionTypes = ( new Set([
         localChatSessionType,
         "copilotcli",
+        "agent-host-copilotcli",
         "claude-code"]));
     }
     _isDebugEligibleSession(sessionResource) {
-        return ( ChatDebugServiceImpl._debugEligibleSessionTypes.has(getChatSessionType(sessionResource))) || ( this._importedSessions.has(sessionResource));
+        const sessionType = getChatSessionType(sessionResource);
+        return (
+        ChatDebugServiceImpl._debugEligibleSessionTypes.has(sessionType)) || (sessionType.startsWith("remote-") && sessionType.endsWith("-copilotcli")) || ( this._importedSessions.has(sessionResource));
     }
     log(sessionResource, name, details, level = ChatDebugLogLevel.Info, options) {
         if (!this._isDebugEligibleSession(sessionResource)) {
@@ -313,6 +318,7 @@ class ChatDebugServiceImpl extends Disposable {
             cts.dispose();
             this._invocationCts.delete(sessionResource);
         }
+        this._onDidEndSession.fire(sessionResource);
     }
     _clearProviderEvents(sessionResource) {
         const buffer = this._sessionBuffers.get(sessionResource);

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

@@ -45,6 +45,19 @@ export declare class ChatService extends Disposable implements IChatService {
     private readonly _sessionModels;
     private readonly _pendingRequests;
     private readonly _queuedRequestDeferreds;
+    /**
+     * In-flight untitled→real materializations, keyed by the original untitled
+     * chat session resource. A first send to an untitled contributed session
+     * stores the promise that resolves to the newly minted real resource (or
+     * `undefined` on failure). A concurrent second send for the same untitled
+     * resource awaits this instead of materializing a second real session.
+     *
+     * The committed (settled) untitled→real mapping is owned by
+     * {@link IChatSessionsService} (published via `setMaterializedSessionResource`
+     * and read via `getMaterializedSessionResource`); this map only tracks the
+     * transient in-flight serialization.
+     */
+    private readonly _inFlightUntitledMaterializations;
     private _saveModelsEnabled;
     private _transferredSessionResource;
     get transferredSessionResource(): URI | undefined;
@@ -132,6 +145,20 @@ export declare class ChatService extends Disposable implements IChatService {
     resendRequest(request: IChatRequestModel, options?: IChatSendRequestOptions): Promise<void>;
     private queuePendingRequest;
     sendRequest(sessionResource: URI, request: string, options?: IChatSendRequestOptions): Promise<ChatSendResult>;
+    /**
+     * Converts an untitled contributed chat session into its real session on the
+     * first send and returns the real model/resource so the caller can re-target
+     * the request. Serialized per untitled resource: a first send stores an
+     * in-flight promise, and a concurrent second send awaits it and converges on
+     * the same real session (where the caller's pending-request check then rejects
+     * the duplicate) instead of minting a second real session.
+     *
+     * Returns `undefined` when no conversion happened — either there is no
+     * `newChatSessionItem` handler / the handler declined, or a concurrent
+     * materialization failed — in which case the caller keeps using the untitled
+     * session (the original behavior).
+     */
+    private _materializeUntitledSession;
     private getAttachmentCapabilitiesForParser;
     private parseChatRequest;
     private refreshFollowupsCancellationToken;
@@ -162,6 +189,7 @@ export declare class ChatService extends Disposable implements IChatService {
         requestId: string;
         kind: ChatRequestQueueKind;
     }[]): void;
+    sendPendingRequestImmediately(sessionResource: URI, requestId: string): Promise<void>;
     hasSessions(): boolean;
     transferChatSession(transferredSessionResource: URI, toWorkspace: URI): Promise<void>;
     getChatStorageFolder(): URI;