@codingame/monaco-vscode-api 36.2.6 → 37.0.0

package/vscode/src/vs/workbench/contrib/chat/browser/chatSetup/chatSetup.d.ts

@@ -1,6 +1,11 @@
+import { ThemeIcon } from "../../../../../base/common/themables.js";
+import { IDisposable } from "../../../../../base/common/lifecycle.js";
+import { CancellationToken } from "../../../../../base/common/cancellation.js";
 import { ICommandService } from "../../../../../platform/commands/common/commands.service.js";
+import { RawContextKey } from "../../../../../platform/contextkey/common/contextkey.js";
 import { ILogService } from "../../../../../platform/log/common/log.service.js";
 import { IExtensionsWorkbenchService } from "../../../extensions/common/extensions.service.js";
+export declare const ChatSetupDialogVisibleContext: RawContextKey<boolean>;
 export type InstallChatClassification = {
     owner: "bpasero";
     comment: "Provides insight into chat installation.";
@@ -47,12 +52,40 @@ export declare enum ChatSetupStrategy {
     SetupWithoutEnterpriseProvider = 2,
     SetupWithEnterpriseProvider = 3,
     SetupWithGoogleProvider = 4,
-    SetupWithAppleProvider = 5
+    SetupWithAppleProvider = 5,
+    SetupWithMicrosoftProvider = 6
 }
 export type ChatSetupResultValue = boolean | undefined;
 export interface IChatSetupResult {
     readonly success: ChatSetupResultValue;
     readonly dialogSkipped: boolean;
+    readonly error?: Error;
+    readonly errorAlreadyHandled?: boolean;
+}
+export declare class ChatSetupError extends Error {
+    readonly originalError: Error;
+    readonly userNotified: boolean;
+    constructor(originalError: Error, userNotified: boolean);
+}
+export interface IChatSetupRunOptions {
+    readonly disableChatViewReveal?: boolean;
+    readonly forceSignInDialog?: boolean;
+    readonly cancellationToken?: CancellationToken;
+    readonly additionalScopes?: readonly string[];
+    readonly forceAnonymous?: ChatSetupAnonymous;
+    readonly dialogIcon?: ThemeIcon;
+    readonly dialogTitle?: string;
+    readonly setupStrategy?: ChatSetupStrategy;
+    readonly disableCloseButton?: boolean;
+    readonly dialogExtraClasses?: readonly string[];
+    readonly allowContinueWithoutSignIn?: boolean;
+    readonly renderDialogFooter?: (container: HTMLElement) => IDisposable | undefined;
+    readonly onDidDismissDialog?: () => void;
+    readonly onSignInStarted?: (cancel: () => void) => void;
+}
+export interface IChatSetupCommandOptions extends IChatSetupRunOptions {
+    readonly inputValue?: string;
+    readonly returnResult?: boolean;
 }
 export declare function refreshTokens(commandService: ICommandService): void;
 /**

package/vscode/src/vs/workbench/contrib/chat/browser/chatSetup/chatSetup.js

@@ -1,4 +1,5 @@
 
+import { RawContextKey } from '../../../../../platform/contextkey/common/contextkey.js';
 import { ExtensionIdentifier } from '../../../../../platform/extensions/common/extensions.js';
 import product from '../../../../../platform/product/common/product.js';
 import { localize } from '../../../../../nls.js';
@@ -9,6 +10,7 @@ const defaultChat = {
     chatRefreshTokenCommand: product.defaultChatAgent?.chatRefreshTokenCommand ?? "",
     providerExtensionId: product.defaultChatAgent?.providerExtensionId ?? ""
 };
+const ChatSetupDialogVisibleContext = ( new RawContextKey("chatSetupDialogVisible", false));
 var ChatSetupAnonymous;
 (function(ChatSetupAnonymous) {
     ChatSetupAnonymous[ChatSetupAnonymous["Disabled"] = 0] = "Disabled";
@@ -29,7 +31,18 @@ var ChatSetupStrategy;
     ChatSetupStrategy[ChatSetupStrategy["SetupWithEnterpriseProvider"] = 3] = "SetupWithEnterpriseProvider";
     ChatSetupStrategy[ChatSetupStrategy["SetupWithGoogleProvider"] = 4] = "SetupWithGoogleProvider";
     ChatSetupStrategy[ChatSetupStrategy["SetupWithAppleProvider"] = 5] = "SetupWithAppleProvider";
+    ChatSetupStrategy[ChatSetupStrategy["SetupWithMicrosoftProvider"] = 6] = "SetupWithMicrosoftProvider";
 })(ChatSetupStrategy || (ChatSetupStrategy = {}));
+class ChatSetupError extends Error {
+    constructor(originalError, userNotified) {
+        super(originalError.message, {
+            cause: originalError
+        });
+        this.originalError = originalError;
+        this.userNotified = userNotified;
+        this.name = originalError.name;
+    }
+}
 function refreshTokens(commandService) {
     commandService.executeCommand(defaultChat.chatRefreshTokenCommand).catch(() => {});
 }
@@ -56,7 +69,7 @@ async function maybeEnableAuthExtension(extensionsWorkbenchService, logService)
         );
         try {
             await extensionsWorkbenchService.setEnablement([providerExtension], EnablementState.EnabledGlobally);
-            await extensionsWorkbenchService.updateRunningExtensions(( localize(7225, "Enabling GitHub Authentication")));
+            await extensionsWorkbenchService.updateRunningExtensions(( localize(8454, "Enabling GitHub Authentication")));
             return true;
         } catch (error) {
             logService.error(
@@ -69,4 +82,4 @@ async function maybeEnableAuthExtension(extensionsWorkbenchService, logService)
     return false;
 }
 
-export { ChatSetupAnonymous, ChatSetupStep, ChatSetupStrategy, buildUpgradeUrlWithRedirect, maybeEnableAuthExtension, refreshTokens };
+export { ChatSetupAnonymous, ChatSetupDialogVisibleContext, ChatSetupError, ChatSetupStep, ChatSetupStrategy, buildUpgradeUrlWithRedirect, maybeEnableAuthExtension, refreshTokens };

package/vscode/src/vs/workbench/contrib/chat/browser/chatSubmitRequestHandlerService.service.d.ts

@@ -0,0 +1,9 @@
+import { IDisposable } from "../../../../base/common/lifecycle.js";
+import { IChatSubmitRequestHandler, IChatSubmitRequest } from "@codingame/monaco-vscode-chat-service-override/vscode/vs/workbench/contrib/chat/browser/chatSubmitRequestHandlerService";
+export declare const IChatSubmitRequestHandlerService: import("../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IChatSubmitRequestHandlerService>;
+/** Registry for provider-specific pre-submit chat handlers. */
+export interface IChatSubmitRequestHandlerService {
+    readonly _serviceBrand: undefined;
+    register(handler: IChatSubmitRequestHandler): IDisposable;
+    tryHandle(request: IChatSubmitRequest): Promise<boolean>;
+}

package/vscode/src/vs/workbench/contrib/chat/browser/chatSubmitRequestHandlerService.service.js

@@ -0,0 +1,6 @@
+
+import { createDecorator } from '../../../../platform/instantiation/common/instantiation.js';
+
+const IChatSubmitRequestHandlerService = ( createDecorator("chatSubmitRequestHandlerService"));
+
+export { IChatSubmitRequestHandlerService };

package/vscode/src/vs/workbench/contrib/chat/browser/copilotCliEventsUri.d.ts

@@ -0,0 +1,106 @@
+import type { IProcessEnvironment } from "../../../../base/common/platform.js";
+import { URI } from "../../../../base/common/uri.js";
+import { IRemoteAgentHostConnectionInfo } from "../../../../platform/agentHost/common/remoteAgentHostService.js";
+export declare const COPILOT_CLI_LOCAL_AH_SCHEME = "agent-host-copilotcli";
+export declare const COPILOT_CLI_EH_SCHEME = "copilotcli";
+/** Agent-host provider id for Copilot CLI, used to build backend (AHP channel) session URIs. */
+export declare const COPILOT_CLI_AGENT_PROVIDER = "copilotcli";
+/**
+ * Builds the local `events.jsonl` URI under `<COPILOT_HOME>/session-state/<rawId>/`.
+ *
+ * Used for both the local Agent Host Copilot CLI provider and the
+ * extension-host Copilot CLI provider, which share the same on-disk layout
+ * and the same chat session URI shape (`copilotcli:/<rawId>`).
+ */
+export declare function buildLocalEventsUri(userHome: URI, rawSessionId: string, environment?: IProcessEnvironment): URI;
+/**
+ * Builds the local `<COPILOT_HOME>/logs` directory URI.
+ */
+export declare function buildLocalCopilotLogsUri(userHome: URI, environment?: IProcessEnvironment): URI;
+/**
+ * Builds the local `<COPILOT_HOME>/session-state` directory URI.
+ */
+export declare function buildLocalSessionStateUri(userHome: URI, environment?: IProcessEnvironment): URI;
+/**
+ * Builds a `vscode-agent-host://` URI for the `events.jsonl` file inside
+ * the host's user home directory, using the connection's reported
+ * `defaultDirectory` (set from `os.homedir()` on the host during the
+ * AHP handshake).
+ *
+ * The path is joined at the URI-path level using forward slashes, which
+ * works for both POSIX hosts (`/home/me`) and Windows hosts whose
+ * `URI.file(os.homedir()).path` is also forward-slash-rooted (e.g.
+ * `/c:/Users/me`). Returns `undefined` if the host did not report a
+ * usable `defaultDirectory`.
+ */
+export declare function buildRemoteEventsUri(connection: IRemoteAgentHostConnectionInfo, rawSessionId: string): URI | undefined;
+/**
+ * Builds a `vscode-agent-host://` URI for the host's `~/.copilot/logs`
+ * directory, using the connection's reported home directory.
+ */
+export declare function buildRemoteCopilotLogsUri(connection: IRemoteAgentHostConnectionInfo): URI | undefined;
+/**
+ * Parses the connection authority out of a remote AH chat session scheme
+ * of the form `remote-<authority>-copilotcli`. Returns `undefined` for
+ * any other scheme, including the local `copilotcli` scheme.
+ */
+export declare function parseRemoteAuthorityFromScheme(scheme: string): string | undefined;
+/**
+ * Extracts the raw Copilot CLI session id from a chat session resource.
+ */
+export declare function getCopilotCliSessionRawId(sessionResource: URI | undefined): string | undefined;
+/**
+ * Drops the legacy extension-host row for any Copilot CLI session that also has
+ * a local agent-host row, so a migrated session is listed once.
+ *
+ * Only `copilotcli:` is ever dropped, and only against `agent-host-copilotcli:`.
+ * A remote agent-host session (`remote-<authority>-copilotcli:`) shares the
+ * Copilot CLI session type and can carry the same raw id as a local one, but is
+ * a different session and must never be deduped against it.
+ */
+export declare function dedupeMigratedCopilotCliSessions<T>(items: readonly T[], resourceOf: (item: T) => URI): T[];
+/**
+ * The local agent-host resource a legacy extension-host Copilot CLI session
+ * would migrate to, or `undefined` when `resource` is not such a session.
+ * Synchronous by design: open paths must not pay a round-trip for the
+ * overwhelmingly common case of a session that is not legacy.
+ */
+export declare function migratedCopilotCliResource(resource: URI | undefined): URI | undefined;
+export type ResolveEventsUriResult = {
+    readonly kind: "ok";
+    readonly resource: URI;
+} | {
+    readonly kind: "no-session";
+} | {
+    readonly kind: "unsupported-scheme";
+    readonly scheme: string;
+} | {
+    readonly kind: "remote-not-connected";
+    readonly authority: string;
+} | {
+    readonly kind: "remote-no-home";
+    readonly authority: string;
+};
+/**
+ * Pure resolver for tests. Translates a chat session resource into the
+ * `events.jsonl` URI for the corresponding Copilot CLI session, or
+ * returns a structured error.
+ */
+export declare function resolveEventsUri(sessionResource: URI | undefined, userHome: URI, getConnectionByAuthority: (authority: string) => IRemoteAgentHostConnectionInfo | undefined, environment?: IProcessEnvironment): ResolveEventsUriResult;
+/**
+ * Resolves the host-local filesystem path string of a Copilot CLI session's
+ * `events.jsonl`, suitable for tooling that runs **on the host** (e.g. the
+ * agent's terminal), as opposed to a workbench {@link URI} consumed by the
+ * file service.
+ *
+ * Reuses {@link resolveEventsUri} so it stays in lockstep with the resolution
+ * used by the chat debug panel and the "Open Copilot CLI State File" command,
+ * then unwraps the result into a plain path:
+ * - a local `file://` URI becomes its `fsPath` (same machine as the host).
+ * - a remote `vscode-agent-host://` URI is unwrapped to the underlying file
+ *   URI whose `path` is the real path on the remote host the agent runs on.
+ *
+ * Returns `undefined` when the session is not a Copilot CLI session or the
+ * path cannot be resolved (e.g. a remote host that reported no home directory).
+ */
+export declare function buildHostLocalEventsPath(sessionResource: URI | undefined, userHome: URI, getConnectionByAuthority: (authority: string) => IRemoteAgentHostConnectionInfo | undefined, environment?: IProcessEnvironment): string | undefined;

package/vscode/src/vs/workbench/contrib/chat/browser/copilotCliEventsUri.js

@@ -0,0 +1,161 @@
+
+import { Schemas } from '../../../../base/common/network.js';
+import { env } from '../../../../base/common/process.js';
+import { joinPath } from '../../../../base/common/resources.js';
+import { URI } from '../../../../base/common/uri.js';
+import { getCopilotHomePath } from '../../../../platform/agentHost/common/copilotHome.js';
+import { parseRemoteAgentHostSessionTypeAuthority } from '../../../../platform/agentHost/common/agentHostSessionType.js';
+import { agentHostAuthority, toAgentHostUri, fromAgentHostUri } from '../../../../platform/agentHost/common/agentHostUri.js';
+
+const COPILOT_CLI_PROVIDER = "copilotcli";
+const COPILOT_CLI_LOCAL_AH_SCHEME = `agent-host-${COPILOT_CLI_PROVIDER}`;
+const COPILOT_CLI_EH_SCHEME = COPILOT_CLI_PROVIDER;
+const COPILOT_CLI_AGENT_PROVIDER = COPILOT_CLI_PROVIDER;
+function buildLocalEventsUri(userHome, rawSessionId, environment = env) {
+    return joinPath(
+        buildLocalCopilotHomeUri(userHome, environment),
+        "session-state",
+        rawSessionId,
+        "events.jsonl"
+    );
+}
+function buildLocalCopilotLogsUri(userHome, environment = env) {
+    return joinPath(buildLocalCopilotHomeUri(userHome, environment), "logs");
+}
+function buildLocalSessionStateUri(userHome, environment = env) {
+    return joinPath(buildLocalCopilotHomeUri(userHome, environment), "session-state");
+}
+function buildRemoteEventsUri(connection, rawSessionId) {
+    const homePath = connection.defaultDirectory;
+    if (!homePath) {
+        return undefined;
+    }
+    const trimmed = homePath.endsWith("/") ? homePath.slice(0, -1) : homePath;
+    const remoteFileUri = ( URI.from({
+        scheme: "file",
+        path: `${trimmed}/.copilot/session-state/${rawSessionId}/events.jsonl`
+    }));
+    const authority = agentHostAuthority(connection.address);
+    return toAgentHostUri(remoteFileUri, authority);
+}
+function buildRemoteCopilotLogsUri(connection) {
+    const homePath = connection.defaultDirectory;
+    if (!homePath) {
+        return undefined;
+    }
+    const trimmed = homePath.endsWith("/") ? homePath.slice(0, -1) : homePath;
+    const remoteFileUri = ( URI.from({
+        scheme: "file",
+        path: `${trimmed}/.copilot/logs`
+    }));
+    const authority = agentHostAuthority(connection.address);
+    return toAgentHostUri(remoteFileUri, authority);
+}
+function parseRemoteAuthorityFromScheme(scheme) {
+    return parseRemoteAgentHostSessionTypeAuthority(scheme, COPILOT_CLI_PROVIDER);
+}
+function getCopilotCliSessionRawId(sessionResource) {
+    if (!sessionResource) {
+        return undefined;
+    }
+    if (sessionResource.scheme !== COPILOT_CLI_LOCAL_AH_SCHEME && sessionResource.scheme !== COPILOT_CLI_EH_SCHEME && !parseRemoteAuthorityFromScheme(sessionResource.scheme)) {
+        return undefined;
+    }
+    return getRawSessionId(sessionResource);
+}
+function dedupeMigratedCopilotCliSessions(items, resourceOf) {
+    let migratedRawIds;
+    for (const item of items) {
+        const resource = resourceOf(item);
+        if (resource.scheme === COPILOT_CLI_LOCAL_AH_SCHEME) {
+            const rawId = getCopilotCliSessionRawId(resource);
+            if (rawId) {
+                (migratedRawIds ??= ( new Set())).add(rawId);
+            }
+        }
+    }
+    if (!migratedRawIds) {
+        return items.slice();
+    }
+    return items.filter(item => {
+        const resource = resourceOf(item);
+        if (resource.scheme !== COPILOT_CLI_EH_SCHEME) {
+            return true;
+        }
+        const rawId = getCopilotCliSessionRawId(resource);
+        return !rawId || !( migratedRawIds.has(rawId));
+    });
+}
+function migratedCopilotCliResource(resource) {
+    if (resource?.scheme !== COPILOT_CLI_EH_SCHEME) {
+        return undefined;
+    }
+    const rawId = getCopilotCliSessionRawId(resource);
+    return rawId ? ( URI.from({
+        scheme: COPILOT_CLI_LOCAL_AH_SCHEME,
+        path: `/${rawId}`
+    })) : undefined;
+}
+function resolveEventsUri(sessionResource, userHome, getConnectionByAuthority, environment = env) {
+    if (!sessionResource) {
+        return {
+            kind: "no-session"
+        };
+    }
+    const rawId = getRawSessionId(sessionResource);
+    if (!rawId) {
+        return {
+            kind: "no-session"
+        };
+    }
+    if (sessionResource.scheme === COPILOT_CLI_LOCAL_AH_SCHEME || sessionResource.scheme === COPILOT_CLI_EH_SCHEME) {
+        return {
+            kind: "ok",
+            resource: buildLocalEventsUri(userHome, rawId, environment)
+        };
+    }
+    const remoteAuthority = parseRemoteAuthorityFromScheme(sessionResource.scheme);
+    if (remoteAuthority) {
+        const connection = getConnectionByAuthority(remoteAuthority);
+        if (!connection) {
+            return {
+                kind: "remote-not-connected",
+                authority: remoteAuthority
+            };
+        }
+        const resource = buildRemoteEventsUri(connection, rawId);
+        if (!resource) {
+            return {
+                kind: "remote-no-home",
+                authority: remoteAuthority
+            };
+        }
+        return {
+            kind: "ok",
+            resource
+        };
+    }
+    return {
+        kind: "unsupported-scheme",
+        scheme: sessionResource.scheme
+    };
+}
+function getRawSessionId(sessionResource) {
+    const rawId = sessionResource.path.startsWith("/") ? sessionResource.path.substring(1) : sessionResource.path;
+    return rawId || undefined;
+}
+function buildHostLocalEventsPath(sessionResource, userHome, getConnectionByAuthority, environment = env) {
+    const result = resolveEventsUri(sessionResource, userHome, getConnectionByAuthority, environment);
+    if (result.kind !== "ok") {
+        return undefined;
+    }
+    if (result.resource.scheme === Schemas.file) {
+        return result.resource.fsPath;
+    }
+    return fromAgentHostUri(result.resource).path.replace(/^\/([a-zA-Z]:)/, "$1");
+}
+function buildLocalCopilotHomeUri(userHome, environment) {
+    return URI.file(getCopilotHomePath(userHome.fsPath, environment));
+}
+
+export { COPILOT_CLI_AGENT_PROVIDER, COPILOT_CLI_EH_SCHEME, COPILOT_CLI_LOCAL_AH_SCHEME, buildHostLocalEventsPath, buildLocalCopilotLogsUri, buildLocalEventsUri, buildLocalSessionStateUri, buildRemoteCopilotLogsUri, buildRemoteEventsUri, dedupeMigratedCopilotCliSessions, getCopilotCliSessionRawId, migratedCopilotCliResource, parseRemoteAuthorityFromScheme, resolveEventsUri };

package/vscode/src/vs/workbench/contrib/chat/browser/enablementActions.d.ts

@@ -0,0 +1,20 @@
+import { Action, IAction } from "../../../../base/common/actions.js";
+import { IWorkspaceContextService } from "../../../../platform/workspace/common/workspace.service.js";
+import { ContributionEnablementState, IEnablementModel } from "../common/enablement.js";
+/**
+ * Creates the four standard enablement actions (Enable, Enable Workspace,
+ * Disable, Disable Workspace) for a contribution identified by a string key.
+ */
+export declare function createEnablementActions(key: string, enablementModel: IEnablementModel, idPrefix: string): [
+    enable: Action,
+    enableWorkspace: Action,
+    disable: Action,
+    disableWorkspace: Action
+];
+/**
+ * Builds the standard enablement context-menu action group for a
+ * contribution. Returns either the enable or disable actions depending
+ * on the current state, with workspace variants included only when a
+ * workspace is open.
+ */
+export declare function buildEnablementContextMenuGroup(enablementState: ContributionEnablementState, key: string, enablementModel: IEnablementModel, workspaceContextService: IWorkspaceContextService, idPrefix: string): IAction[];

package/vscode/src/vs/workbench/contrib/chat/browser/enablementActions.js

@@ -0,0 +1,40 @@
+
+import { Action } from '../../../../base/common/actions.js';
+import { localize } from '../../../../nls.js';
+import { WorkbenchState } from '../../../../platform/workspace/common/workspace.js';
+import { ContributionEnablementState, isContributionDisabled } from '../common/enablement.js';
+
+function createEnablementActions(key, enablementModel, idPrefix) {
+    return [( new Action(`${idPrefix}.enable`, ( localize(8656, "Enable")), undefined, true, () => {
+        enablementModel.setEnabled(key, ContributionEnablementState.EnabledProfile);
+        return Promise.resolve();
+    })), ( new Action(`${idPrefix}.enableForWorkspace`, ( localize(8657, "Enable (Workspace)")), undefined, true, () => {
+        enablementModel.setEnabled(key, ContributionEnablementState.EnabledWorkspace);
+        return Promise.resolve();
+    })), ( new Action(`${idPrefix}.disable`, ( localize(8658, "Disable")), undefined, true, () => {
+        enablementModel.setEnabled(key, ContributionEnablementState.DisabledProfile);
+        return Promise.resolve();
+    })), ( new Action(`${idPrefix}.disableForWorkspace`, ( localize(8659, "Disable (Workspace)")), undefined, true, () => {
+        enablementModel.setEnabled(key, ContributionEnablementState.DisabledWorkspace);
+        return Promise.resolve();
+    }))];
+}
+function buildEnablementContextMenuGroup(enablementState, key, enablementModel, workspaceContextService, idPrefix) {
+    const hasWorkspace = workspaceContextService.getWorkbenchState() !== WorkbenchState.EMPTY;
+    const [enable, enableWorkspace, disable, disableWorkspace] = createEnablementActions(key, enablementModel, idPrefix);
+    const actions = [];
+    if (isContributionDisabled(enablementState)) {
+        actions.push(enable);
+        if (hasWorkspace) {
+            actions.push(enableWorkspace);
+        }
+    } else {
+        actions.push(disable);
+        if (hasWorkspace) {
+            actions.push(disableWorkspace);
+        }
+    }
+    return actions;
+}
+
+export { buildEnablementContextMenuGroup, createEnablementActions };

package/vscode/src/vs/workbench/contrib/chat/browser/feedbackSurvey/chatModelFeedbackSurveyService.service.d.ts

@@ -0,0 +1,38 @@
+import { Event } from "../../../../../base/common/event.js";
+import { URI } from "../../../../../base/common/uri.js";
+import { IChatResponseViewModel } from "../../common/model/chatViewModel.js";
+import { IChatModelFeedbackSurveyChangeEvent, IChatModelFeedbackSurveyState } from "@codingame/monaco-vscode-katex-common/vscode/vs/workbench/contrib/chat/browser/feedbackSurvey/chatModelFeedbackSurveyService";
+export declare const IChatModelFeedbackSurveyService: import("../../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IChatModelFeedbackSurveyService>;
+export interface IChatModelFeedbackSurveyService {
+    readonly _serviceBrand: undefined;
+    /** Fires when a response's survey state changes, so the row can re-render. */
+    readonly onDidChangeSurveyState: Event<IChatModelFeedbackSurveyChangeEvent>;
+    /**
+    * Fires when the configured survey changes, including when it first resolves. Rows rendered
+    * before that point carry no control until they re-render, so they listen for this.
+    */
+    readonly onDidChangeConfiguration: Event<void>;
+    /**
+    * The survey attached to a response, or `undefined` when the config does not apply to it.
+    *
+    * Presence depends only on the `match` rules and never on the prompting heuristics, so the
+    * control does not come and go between responses. Repeated calls return the same state, so a
+    * row scrolling back into view keeps its control and is not asked to prompt twice.
+    */
+    getSurvey(response: IChatResponseViewModel): IChatModelFeedbackSurveyState | undefined;
+    /**
+    * Opens the survey, or closes it when it is already showing. Manual opens are never rate
+    * limited, because the prompting rules only exist to pace surveys the user did not ask for.
+    */
+    toggle(response: IChatResponseViewModel): void;
+    /**
+    * Reports that the user moved the model picker from one model to another. Leaving a surveyed
+    * model for an unsurveyed one is the strongest signal that the model was wrong.
+    */
+    notifyModelSwitchedAway(sessionResource: URI, fromModelId: string, toModelId: string): void;
+    answerChoice(response: IChatResponseViewModel, stepId: string, optionId: string): void;
+    submit(response: IChatResponseViewModel, comment?: string): void;
+    dismiss(response: IChatResponseViewModel): void;
+    /** Records in-progress free text without re-rendering, so it survives row recycling. */
+    setCommentDraft(response: IChatResponseViewModel, comment: string): void;
+}

package/vscode/src/vs/workbench/contrib/chat/browser/feedbackSurvey/chatModelFeedbackSurveyService.service.js

@@ -0,0 +1,6 @@
+
+import { createDecorator } from '../../../../../platform/instantiation/common/instantiation.js';
+
+const IChatModelFeedbackSurveyService = ( createDecorator("chatModelFeedbackSurveyService"));
+
+export { IChatModelFeedbackSurveyService };

package/vscode/src/vs/workbench/contrib/chat/browser/pcmCaptureWorklet.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Control message the main thread posts to the worklet to ask it to emit any
+ * partially-filled buffer immediately (rather than waiting for it to reach the
+ * chunk size) and acknowledge. Used to flush the trailing audio before capture
+ * is torn down so the final spoken words are not dropped.
+ */
+export declare const PCM_FLUSH_REQUEST = "vscode-pcm-flush";
+/** Control message the worklet posts back after emitting its buffered tail. */
+export declare const PCM_FLUSH_ACK = "vscode-pcm-flushed";
+/**
+ * Subset of {@link MessagePort} used by {@link wirePcmCapturePort}: it posts
+ * flush requests and receives chunk/ack messages.
+ */
+export type IPcmCapturePort = Pick<MessagePort, "postMessage" | "onmessage">;
+/** Timer functions used by {@link wirePcmCapturePort} (satisfied by `window`). */
+export type IPcmCaptureTimers = Pick<Window & typeof globalThis, "setTimeout" | "clearTimeout">;
+/**
+ * Wire the main-thread side of the capture worklet's message port: route audio
+ * chunks to `onChunk`, and expose a `flush` that asks the worklet to emit its
+ * partial trailing buffer and resolves once the acknowledgment arrives (or after
+ * a timeout if the audio thread never responds).
+ */
+export declare function wirePcmCapturePort(port: IPcmCapturePort, timers: IPcmCaptureTimers, onChunk: (samples: Float32Array) => void): {
+    flush(): Promise<void>;
+};
+/**
+ * A PCM capture worklet node together with a `flush` that drains its
+ * partially-filled trailing buffer.
+ */
+export interface IPcmCaptureNode {
+    /**
+     * The capture node. Not connected to the audio graph; the caller is
+     * responsible for connecting it (typically source -> node -> destination)
+     * and for disposing it via `node.disconnect()` and clearing
+     * `node.port.onmessage`.
+     */
+    readonly node: AudioWorkletNode;
+    /**
+     * Ask the worklet to emit any audio buffered so far (a partial chunk that
+     * has not yet reached the chunk size) and resolve once it has. The buffered
+     * samples are delivered through the same `onChunk` callback before this
+     * resolves, so callers can flush the trailing audio to their backend before
+     * stopping capture. Resolves after a short timeout even if the audio thread
+     * never acknowledges (e.g. the context is already closing).
+     */
+    flush(): Promise<void>;
+}
+/**
+ * Creates an {@link AudioWorkletNode} that captures mono PCM from `context` in
+ * fixed-size chunks, invoking `onChunk` on the main thread for every chunk. The
+ * worklet module is loaded from a blob URL, which the renderer's `script-src`
+ * CSP allows (worklet scripts fall back to `script-src`).
+ */
+export declare function createPcmCaptureNode(window: Window & typeof globalThis, context: AudioContext, chunkSize: number, onChunk: (samples: Float32Array) => void): Promise<IPcmCaptureNode>;

package/vscode/src/vs/workbench/contrib/chat/browser/pcmCaptureWorklet.js

@@ -0,0 +1,102 @@
+
+
+const PCM_CAPTURE_PROCESSOR = "vscode-pcm-capture";
+const PCM_FLUSH_REQUEST = "vscode-pcm-flush";
+const PCM_FLUSH_ACK = "vscode-pcm-flushed";
+const FLUSH_TIMEOUT_MS = 250;
+function pcmCaptureWorkletSource(chunkSize) {
+    return `
+class PcmCaptureProcessor extends AudioWorkletProcessor {
+    constructor() {
+        super();
+        this._chunkSize = ${chunkSize};
+        this._buffer = new Float32Array(this._chunkSize);
+        this._offset = 0;
+        this.port.onmessage = e => {
+            if (e.data && e.data.type === '${PCM_FLUSH_REQUEST}') {
+                this._flush();
+                this.port.postMessage({ type: '${PCM_FLUSH_ACK}' });
+            }
+        };
+    }
+    _flush() {
+        if (this._offset > 0) {
+            const chunk = this._buffer.slice(0, this._offset);
+            this.port.postMessage(chunk, [chunk.buffer]);
+            this._offset = 0;
+        }
+    }
+    process(inputs) {
+        const channel = inputs[0] && inputs[0][0];
+        if (channel) {
+            for (let i = 0; i < channel.length; i++) {
+                this._buffer[this._offset++] = channel[i];
+                if (this._offset === this._chunkSize) {
+                    const chunk = this._buffer;
+                    this.port.postMessage(chunk, [chunk.buffer]);
+                    this._buffer = new Float32Array(this._chunkSize);
+                    this._offset = 0;
+                }
+            }
+        }
+        return true;
+    }
+}
+registerProcessor('${PCM_CAPTURE_PROCESSOR}', PcmCaptureProcessor);
+`;
+}
+function wirePcmCapturePort(port, timers, onChunk) {
+    let onFlushed;
+    port.onmessage = e => {
+        const data = e.data;
+        if (data && data.type === PCM_FLUSH_ACK) {
+            onFlushed?.();
+            return;
+        }
+        onChunk(data);
+    };
+    const flush = () => ( new Promise(resolve => {
+        let settled = false;
+        const done = () => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            onFlushed = undefined;
+            timers.clearTimeout(timer);
+            resolve();
+        };
+        onFlushed = done;
+        const timer = timers.setTimeout(done, FLUSH_TIMEOUT_MS);
+        port.postMessage({
+            type: PCM_FLUSH_REQUEST
+        });
+    }));
+    return {
+        flush
+    };
+}
+async function createPcmCaptureNode(window, context, chunkSize, onChunk) {
+    const moduleUrl = URL.createObjectURL(( new Blob([pcmCaptureWorkletSource(chunkSize)], {
+        type: "application/javascript"
+    })));
+    try {
+        await context.audioWorklet.addModule(moduleUrl);
+    } finally {
+        URL.revokeObjectURL(moduleUrl);
+    }
+    const node = new window.AudioWorkletNode(context, PCM_CAPTURE_PROCESSOR, {
+        numberOfInputs: 1,
+        numberOfOutputs: 1,
+        channelCount: 1
+    });
+    const {
+        flush
+    } = wirePcmCapturePort(node.port, window, onChunk);
+    return {
+        node,
+        flush
+    };
+}
+
+export { PCM_FLUSH_ACK, PCM_FLUSH_REQUEST, createPcmCaptureNode, wirePcmCapturePort };