@codingame/monaco-vscode-katex-common 34.1.2 → 35.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-katex-common",
-  "version": "34.1.2",
+  "version": "35.0.0",
   "private": false,
   "description": "VSCode public API plugged on the monaco editor - common package depending on katex",
   "keywords": [],
@@ -15,7 +15,7 @@
   },
   "type": "module",
   "dependencies": {
-    "@codingame/monaco-vscode-api": "34.1.2",
+    "@codingame/monaco-vscode-api": "35.0.0",
     "katex": "0.16.45",
     "marked": "14.0.0"
   },

package/vscode/src/vs/base/browser/animationSync.d.ts

@@ -0,0 +1,36 @@
+export interface ISynchronizeAnimationsOptions {
+    /**
+     * Also synchronize animations running on descendant elements (e.g. the dots
+     * of a spinner whose animations live on child nodes). Defaults to `false`.
+     */
+    readonly subtree?: boolean;
+    /**
+     * When provided, further narrows synchronization to CSS animations whose
+     * `animation-name` is in this set. Non-keyframe animations (e.g. transitions)
+     * are always skipped regardless of this option.
+     */
+    readonly animationNames?: ReadonlySet<string>;
+}
+/**
+ * Phase-aligns looping CSS animations so that every animation of the same
+ * duration displays the same frame at the same time, regardless of when each
+ * one started.
+ *
+ * All CSS animations share the document's timeline, so anchoring each
+ * animation's `startTime` to the same origin (`0`) forces their `currentTime`
+ * to equal the timeline time — making identical animations run in lock-step.
+ * Per-element `animation-delay` offsets are preserved (they are part of each
+ * animation's own timing), so intentional cascades (e.g. spinner dots) still
+ * work while the group as a whole stays globally in phase.
+ *
+ * Unlike adjusting `animation-delay`, this re-seeks animations that are already
+ * running (Chromium does not reliably re-seek a running animation when its
+ * `animation-delay` changes). Call it whenever an animation (re)starts or
+ * resumes after being paused offscreen — e.g. from an `animationstart` handler
+ * or when an element scrolls back into view.
+ *
+ * @param element The element whose (and optionally whose descendants') CSS
+ * animations should be synchronized.
+ * @param options See {@link ISynchronizeAnimationsOptions}.
+ */
+export declare function synchronizeCSSAnimations(element: HTMLElement, options?: ISynchronizeAnimationsOptions): void;

package/vscode/src/vs/base/browser/animationSync.js

@@ -0,0 +1,23 @@
+
+
+function synchronizeCSSAnimations(element, options) {
+    if (typeof element.getAnimations !== "function") {
+        return;
+    }
+    for (const animation of element.getAnimations({
+        subtree: options?.subtree
+    })) {
+        const animationName = animation.animationName;
+        if (animationName === undefined) {
+            continue;
+        }
+        if (options?.animationNames && !( options.animationNames.has(animationName))) {
+            continue;
+        }
+        try {
+            animation.startTime = 0;
+        } catch {}
+    }
+}
+
+export { synchronizeCSSAnimations };

package/vscode/src/vs/base/browser/ui/pixelSpinner/pixelSpinner.js

@@ -1,13 +1,18 @@
 
 import { registerCss } from '@codingame/monaco-vscode-api/css';
 import { h, onDidUnregisterWindow, getWindow } from '@codingame/monaco-vscode-api/vscode/vs/base/browser/dom';
+import { synchronizeCSSAnimations } from '../../animationSync.js';
 import * as pixelSpinner from './pixelSpinner.css';
 
 registerCss(pixelSpinner);
 function createPixelSpinner(parent, options) {
-    const rootClass = "span.monaco-pixel-spinner";
+    const variant = options?.variant ?? "grid";
+    const rootClass = variant === "ring" ? "span.monaco-pixel-spinner.monaco-pixel-spinner-ring" : "span.monaco-pixel-spinner";
     const root = h(rootClass).root;
-    {
+    if (options?.ariaLabel) {
+        root.setAttribute("role", "status");
+        root.setAttribute("aria-label", options.ariaLabel);
+    } else {
         root.setAttribute("aria-hidden", "true");
     }
     for (let i = 0; i < 6; i++) {
@@ -18,6 +23,12 @@ function createPixelSpinner(parent, options) {
     return root;
 }
 const PAUSED_CLASS = "monaco-pixel-spinner-paused";
+const SPINNER_ANIMATION_NAMES = ( new Set([
+    "monaco-pixel-spinner-dot-cycle",
+    "monaco-pixel-spinner-dot-cycle-long",
+    "monaco-pixel-spinner-dot-cycle-short",
+    "monaco-pixel-spinner-ring-pulse"
+]));
 const observersByWindow = ( new Map());
 let unregisterWindowListener;
 function getObserverFor(targetWindow) {
@@ -27,6 +38,7 @@ function getObserverFor(targetWindow) {
     let observer = observersByWindow.get(targetWindow);
     if (!observer) {
         observer = new targetWindow.IntersectionObserver(entries => {
+            const toResync = [];
             for (const entry of entries) {
                 const target = entry.target;
                 if (!target.isConnected) {
@@ -34,6 +46,15 @@ function getObserverFor(targetWindow) {
                     continue;
                 }
                 target.classList.toggle(PAUSED_CLASS, !entry.isIntersecting);
+                if (entry.isIntersecting) {
+                    toResync.push(target);
+                }
+            }
+            for (const target of toResync) {
+                synchronizeCSSAnimations(target, {
+                    subtree: true,
+                    animationNames: SPINNER_ANIMATION_NAMES
+                });
             }
         });
         observersByWindow.set(targetWindow, observer);

package/vscode/src/vs/platform/actions/browser/buttonbar.js

@@ -81,6 +81,7 @@ let WorkbenchButtonBar = class WorkbenchButtonBar extends ButtonBar {
                 tooltip = action.tooltip || action.label;
                 tooltip = this._keybindingService.appendKeybinding(tooltip, action.id);
                 btn = this.addButtonWithDropdown({
+                    addPrimaryActionToDropdown: false,
                     secondary: configProvider(action, i)?.isSecondary ?? secondary,
                     actionRunner: this._actionRunner,
                     actions: rest,
@@ -168,14 +169,14 @@ let WorkbenchButtonBar = class WorkbenchButtonBar extends ButtonBar {
         if (secondary.length > 0) {
             const btn = this.addButton({
                 secondary: true,
-                ariaLabel: ( localize(1813, "More Actions")),
+                ariaLabel: ( localize(1816, "More Actions")),
                 small: this._options?.small
             });
             btn.icon = Codicon.dropDownButton;
             btn.element.classList.add("default-colors", "monaco-text-button");
             btn.enabled = true;
             this._updateStore.add(
-                this._hoverService.setupManagedHover(hoverDelegate, btn.element, ( localize(1813, "More Actions")))
+                this._hoverService.setupManagedHover(hoverDelegate, btn.element, ( localize(1816, "More Actions")))
             );
             this._updateStore.add(btn.onDidClick(async () => {
                 this._contextMenuService.showContextMenu({

package/vscode/src/vs/platform/agentHost/common/claudeSessionConfigKeys.d.ts

@@ -5,9 +5,10 @@
  * Claude collapses the platform's two-axis approval model
  * (`autoApprove` × `mode`) onto a single `permissionMode` axis matching
  * the Claude SDK's native `PermissionMode` (see
- * `@anthropic-ai/claude-agent-sdk` typings). The six values mirror
- * the SDK's enum exactly so that the value flowing back into
- * `query({ permissionMode })` requires no translation layer.
+ * `@anthropic-ai/claude-agent-sdk` typings, `sdk.d.ts:1560`). The five
+ * values mirror the SDK enum values that VS Code exposes, excluding
+ * `dontAsk`, so that the value flowing back into `query({ permissionMode })`
+ * requires no translation layer.
  *
  * The platform `Permissions` key (allow/deny tool lists) is reused
  * unchanged from `platformSessionSchema` because the Claude SDK accepts
@@ -19,9 +20,8 @@ export declare enum ClaudeSessionConfigKey {
 }
 /**
  * Permission-mode values advertised in the Claude session-config schema.
- * Mirror of the SDK's `PermissionMode` union for protocol-stable strings.
  */
-export type ClaudePermissionMode = "default" | "acceptEdits" | "bypassPermissions" | "plan" | "dontAsk" | "auto";
+export type ClaudePermissionMode = "default" | "acceptEdits" | "bypassPermissions" | "plan" | "auto";
 /**
  * Single source of truth for narrowing an arbitrary runtime value to the
  * closed {@link ClaudePermissionMode} union. Returns `undefined` for

package/vscode/src/vs/platform/agentHost/common/fileEditDiff.d.ts

@@ -0,0 +1,32 @@
+import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import type { FileEdit } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/state";
+import { FileEditKind } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionState";
+/**
+ * A {@link FileEdit} decoded into parsed URIs and a resolved {@link FileEditKind}.
+ *
+ * The create/delete/rename/edit detection and the "primary resource" rule
+ * (after-URI for create/edit/rename, before-URI for delete) are subtle and
+ * were historically duplicated across several adapters. {@link normalizeFileEdit}
+ * centralizes them so every consumer derives the same shape from a protocol
+ * {@link FileEdit}.
+ */
+export interface INormalizedFileEdit {
+    /** The kind of file operation. */
+    readonly kind: FileEditKind;
+    /** Primary file URI: after-URI for create/edit/rename, before-URI for delete. */
+    readonly resource: URI;
+    /** The before-state file URI, when present (absent for creates). */
+    readonly beforeUri?: URI;
+    /** The after-state file URI, when present (absent for deletes). */
+    readonly afterUri?: URI;
+    /** URI from which the before-content can be read (absent for creates). */
+    readonly beforeContentUri?: URI;
+    /** URI from which the after-content can be read (absent for deletes). */
+    readonly afterContentUri?: URI;
+}
+/**
+ * Decodes a protocol {@link FileEdit} into parsed URIs and a resolved
+ * {@link FileEditKind}. Returns `undefined` when the edit carries no usable
+ * file URI (neither `before` nor `after`).
+ */
+export declare function normalizeFileEdit(edit: FileEdit): INormalizedFileEdit | undefined;

package/vscode/src/vs/platform/agentHost/common/fileEditDiff.js

@@ -0,0 +1,33 @@
+
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { isEqual } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { FileEditKind } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionState';
+
+function normalizeFileEdit(edit) {
+    const beforeUri = edit.before ? ( URI.parse(edit.before.uri)) : undefined;
+    const afterUri = edit.after ? ( URI.parse(edit.after.uri)) : undefined;
+    const resource = afterUri ?? beforeUri;
+    if (!resource) {
+        return undefined;
+    }
+    let kind;
+    if (!beforeUri && afterUri) {
+        kind = FileEditKind.Create;
+    } else if (beforeUri && !afterUri) {
+        kind = FileEditKind.Delete;
+    } else if (beforeUri && afterUri && !isEqual(beforeUri, afterUri)) {
+        kind = FileEditKind.Rename;
+    } else {
+        kind = FileEditKind.Edit;
+    }
+    return {
+        kind,
+        resource,
+        beforeUri,
+        afterUri,
+        beforeContentUri: edit.before?.content.uri ? ( URI.parse(edit.before.content.uri)) : undefined,
+        afterContentUri: edit.after?.content.uri ? ( URI.parse(edit.after.content.uri)) : undefined
+    };
+}
+
+export { normalizeFileEdit };

package/vscode/src/vs/platform/agentHost/common/meta/agentFeedbackAnnotations.d.ts

@@ -0,0 +1,90 @@
+import type { Annotation } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/state";
+/**
+ * Shared convention for carrying agent-feedback semantics inside an
+ * {@link Annotation._meta} on the agent host annotations channel.
+ *
+ * Feedback items round-trip as annotations on `<session>/annotations`; the
+ * annotation's own fields cover id / resource / range / resolved, and
+ * everything else (lifecycle state, origin kind, code context, PR linkage)
+ * lives under {@link FEEDBACK_ANNOTATION_META_KEY}. This module is the single
+ * place both the server (agent host, which writes feedback annotations from
+ * its server tools) and the client (agents window, which reads them back)
+ * agree on the key and shape, so the two sides cannot drift.
+ */
+/** Namespaced key under {@link Annotation._meta} carrying feedback semantics. */
+export declare const FEEDBACK_ANNOTATION_META_KEY = "vscode.agentFeedback";
+/**
+ * Name of the agent host server tool that reveals review comments the user has
+ * not accepted yet. Shared here (in the layer-neutral `common` module) so the
+ * node-side server tool implementation and the browser-side chat adapter that
+ * renders its confirmation agree on the name without drifting. The agent sees
+ * this name directly (Copilot) or prefixed as `mcp__host__<name>` (Claude).
+ */
+export declare const VIEW_UNREVIEWED_COMMENTS_TOOL_NAME = "viewUnreviewedComments";
+/**
+ * Name of the agent host server tool that adds a comment (agent feedback) to a
+ * file range. Shared here (in the layer-neutral `common` module) so the
+ * node-side server tool implementation and the browser-side chat adapter that
+ * renders its tool call agree on the name without drifting. The agent sees this
+ * name directly (Copilot) or prefixed as `mcp__host__<name>` (Claude).
+ */
+export declare const ADD_COMMENT_TOOL_NAME = "addComment";
+/**
+ * Whether {@link toolName} (a tool name as seen on a tool call) refers to the
+ * {@link VIEW_UNREVIEWED_COMMENTS_TOOL_NAME} server tool. Accepts both the bare
+ * name and the Claude `mcp__<server>__<name>` prefixed form.
+ */
+export declare function isViewUnreviewedCommentsTool(toolName: string): boolean;
+/**
+ * Whether {@link toolName} (a tool name as seen on a tool call) refers to the
+ * {@link ADD_COMMENT_TOOL_NAME} server tool. Accepts both the bare name and the
+ * Claude `mcp__<server>__<name>` prefixed form.
+ */
+export declare function isAddCommentTool(toolName: string): boolean;
+/**
+ * Origin of a feedback item. String values match the client-side
+ * `AgentFeedbackKind` enum so a value written by either side decodes on the
+ * other without translation.
+ */
+export type AgentFeedbackKindValue = "user" | "codeReview" | "prReview";
+/**
+ * Lifecycle state of a feedback item. String values match the client-side
+ * `AgentFeedbackState` enum.
+ */
+export type AgentFeedbackStateValue = "created" | "accepted" | "submitted" | "resolved";
+/**
+ * Feedback semantics carried in an annotation's {@link Annotation._meta}.
+ *
+ * The optional client-only fields ({@link suggestion}, {@link codeSelection},
+ * {@link diffHunks}, {@link sourcePRReviewCommentId}) are populated when a
+ * feedback item is converted from a code- or PR-review comment on the client;
+ * server tools only ever write {@link kind} / {@link state} /
+ * {@link sessionResource}. {@link suggestion} is typed loosely here because
+ * its concrete shape lives in the client (sessions) layer.
+ */
+export interface IFeedbackAnnotationMeta {
+    readonly kind: AgentFeedbackKindValue;
+    readonly state: AgentFeedbackStateValue;
+    readonly sessionResource: string;
+    readonly suggestion?: unknown;
+    readonly codeSelection?: string;
+    readonly diffHunks?: string;
+    readonly sourcePRReviewCommentId?: string;
+    /**
+     * Transient marker set by the client when the user reveals this comment to
+     * the agent via the `viewUnreviewedComments` tool. The server tool returns
+     * exactly the comments carrying this flag (so the result is scoped to the
+     * comments selected for that invocation rather than every accepted review
+     * comment) and clears it once they have been delivered, so a later
+     * invocation does not re-return them.
+     */
+    readonly pendingAgentReveal?: boolean;
+}
+/**
+ * Reads the well-known {@link IFeedbackAnnotationMeta} from an annotation's
+ * `_meta` bag (under {@link FEEDBACK_ANNOTATION_META_KEY}). The annotations
+ * channel is shared, so this validates the required `kind` / `state` /
+ * `sessionResource` fields and returns `undefined` for annotations that aren't
+ * feedback items. Read through this rather than casting the namespaced slot.
+ */
+export declare function readFeedbackAnnotationMeta(annotation: Annotation): IFeedbackAnnotationMeta | undefined;

package/vscode/src/vs/platform/agentHost/common/meta/agentFeedbackAttachments.d.ts

@@ -0,0 +1,30 @@
+import { type MessageAnnotationsAttachment, type MessageAttachment, type SimpleMessageAttachment, type TextRange } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/state";
+export declare const AgentFeedbackAttachmentDisplayKind = "agentFeedback";
+export declare const AgentFeedbackAttachmentMetadataKey = "agentFeedback";
+export interface IAgentFeedbackAttachmentMetadata {
+    readonly sessionResource: string;
+    readonly feedbackItems: readonly IAgentFeedbackAttachmentItemMetadata[];
+}
+export interface IAgentFeedbackAttachmentItemMetadata {
+    readonly id: string;
+    readonly text: string;
+    readonly resourceUri: string;
+    readonly range: TextRange;
+    readonly replies?: readonly string[];
+}
+export declare function isAgentFeedbackAttachment(attachment: MessageAttachment): attachment is SimpleMessageAttachment;
+/**
+ * Agent feedback is sent to agent-host sessions as one
+ * {@link MessageAnnotationsAttachment} per submitted comment, each referencing
+ * the specific annotation(s) on the session's annotations channel. The agent
+ * reads the comment content via the `listComments` tool and should act on the
+ * referenced comments.
+ */
+export declare function isAgentFeedbackAnnotationsAttachment(attachment: MessageAttachment): attachment is MessageAnnotationsAttachment;
+/**
+ * Renders an agent-feedback annotations attachment into the textual hint shown
+ * to the agent. The hint references the attached comment ids and points the
+ * agent at the `listComments` tool to read their content.
+ */
+export declare function renderAgentFeedbackAnnotationsAttachment(attachment: MessageAnnotationsAttachment): string | undefined;
+export declare function getAgentFeedbackAttachmentMetadata(attachment: MessageAttachment): IAgentFeedbackAttachmentMetadata | undefined;

package/vscode/src/vs/platform/agentHost/common/meta/agentToolCallMeta.d.ts

@@ -0,0 +1,65 @@
+import type { ToolCallState } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/state";
+/**
+ * Well-known typed view over a tool call's open `_meta` bag (see
+ * {@link ToolCallState._meta}). Producers and
+ * consumers agree on these keys here so the two sides can't drift; always read
+ * the bag through {@link readToolCallMeta}, which validates each field and drops
+ * wrong-typed values.
+ */
+export interface IToolCallMeta {
+    /**
+     * VS Code rendering hint. `terminal` routes the call to the command/output
+     * renderer, `subagent` to the subagent UI, `search` to the search renderer;
+     * everything else falls through to the generic invocation renderer. Set by
+     * the agent adapter, never matched on raw tool name by the renderer.
+     */
+    readonly toolKind?: ToolKind;
+    /** Shell language for a `terminal` tool call (drives syntax highlighting). */
+    readonly language?: string;
+    /** Short task description for a `subagent` tool call (e.g. "Find related files"). */
+    readonly subagentDescription?: string;
+    /** Agent name for a `subagent` tool call (e.g. "explore"). */
+    readonly subagentAgentName?: string;
+    /** Raw, pre-stringified tool arguments captured for display/debugging. */
+    readonly toolArguments?: unknown;
+    /** Originating MCP server name, when the call came from an MCP server. */
+    readonly mcpServerName?: string;
+    /** Originating MCP tool name, when the call came from an MCP server. */
+    readonly mcpToolName?: string;
+    /** MCP App render data, when the call exposes an interactive App surface. */
+    readonly ui?: IToolCallUiMeta;
+    /**
+     * Set by the host's side-effect layer when the call was auto-approved
+     * because of an `autoApprove` session-config setting (rather than an
+     * explicit user action), so the client can render it as setting-driven.
+     */
+    readonly autoApproveBySetting?: boolean;
+}
+/**
+ * The set of VS Code-recognized tool-call rendering kinds. Add a new value here
+ * (and teach the renderer to handle it) rather than matching on tool name.
+ */
+export type ToolKind = "terminal" | "subagent" | "search";
+/**
+ * MCP App render data carried under {@link IToolCallMeta.ui}. Clients gate
+ * mounting the App webview on both a `resourceUri` and a `channel` being
+ * present.
+ */
+export interface IToolCallUiMeta {
+    /** The MCP App's UI resource URI (an `ui://` resource the App renders). */
+    readonly resourceUri: string;
+    /** AHP `mcp://` channel the App's sub-RPCs route back through, when ready. */
+    readonly channel?: string;
+}
+/**
+ * Reads the well-known {@link IToolCallMeta} keys from a tool call's `_meta`
+ * bag, dropping unknown keys and wrong-typed values.
+ */
+export declare function readToolCallMeta(source: ToolCallState): IToolCallMeta;
+/**
+ * Serializes a typed {@link IToolCallMeta} into the `_meta` record, dropping
+ * `undefined` entries and returning `undefined` when empty. Build a tool call's
+ * `_meta` through this so producers stay in lock-step with
+ * {@link readToolCallMeta}.
+ */
+export declare function toToolCallMeta(meta: IToolCallMeta): Record<string, unknown> | undefined;

package/vscode/src/vs/platform/agentHost/common/sessionConfigKeys.d.ts

@@ -19,14 +19,25 @@ export declare enum SessionConfigKey {
     Isolation = "isolation",
     /** `'branch'` — base branch to work from. */
     Branch = "branch",
-    /** `'mode'` — agent execution mode (interactive / plan). */
+    /** `'mode'` — agent execution mode (interactive / plan / autopilot). */
     Mode = "mode"
 }
 /**
- * The set of enum values the unified permission picker understands for the
- * {@link SessionConfigKey.AutoApprove} property.
+ * The set of enum values the unified permission picker *tolerates* for the
+ * {@link SessionConfigKey.AutoApprove} property when deciding whether a
+ * session's schema is "well-known" (and therefore handled by the dedicated
+ * permission picker rather than the generic per-property fallback).
  *
- * `default` is the required baseline level; `autoApprove` and `autopilot`
- * are optional (an agent may choose to advertise a subset).
+ * `default` is the required baseline level; `autoApprove` is the offered
+ * elevated level. `assisted` and `autopilot` are retained here purely for
+ * backward/forward compatibility so a session whose schema was resolved by an
+ * older or newer agent host (advertising those values) still renders the
+ * dedicated picker rather than disappearing. The picker itself only ever
+ * *offers* `default` / `autoApprove` (see the delegate's `availableLevels`).
  */
 export declare const KNOWN_AUTO_APPROVE_VALUES: ReadonlySet<string>;
+/**
+ * The set of enum values understood for the {@link SessionConfigKey.Mode}
+ * property: the agent execution mode axis.
+ */
+export declare const KNOWN_MODE_VALUES: ReadonlySet<string>;

package/vscode/src/vs/platform/agentHost/common/sessionConfigKeys.js

@@ -8,6 +8,7 @@ var SessionConfigKey;
     SessionConfigKey["Branch"] = "branch";
     SessionConfigKey["Mode"] = "mode";
 })(SessionConfigKey || (SessionConfigKey = {}));
-const KNOWN_AUTO_APPROVE_VALUES = ( new Set(["default", "autoApprove", "autopilot"]));
+const KNOWN_AUTO_APPROVE_VALUES = ( new Set(["default", "assisted", "autoApprove", "autopilot"]));
+const KNOWN_MODE_VALUES = ( new Set(["interactive", "plan", "autopilot"]));
 
-export { KNOWN_AUTO_APPROVE_VALUES, SessionConfigKey };
+export { KNOWN_AUTO_APPROVE_VALUES, KNOWN_MODE_VALUES, SessionConfigKey };

package/vscode/src/vs/platform/agentHost/common/state/protocol/channels-resource-watch/reducer.d.ts

@@ -0,0 +1,21 @@
+import type { ResourceWatchState } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-resource-watch/state";
+import type { ResourceWatchAction } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/action-origin.generated";
+/**
+ * Pure reducer for resource-watch state. Handles every
+ * {@link ResourceWatchAction} variant.
+ *
+ * Watches are intentionally event-pass-through: change events are
+ * delivered via `resourceWatch/changed` actions but the reducer keeps no
+ * history of them. The state therefore tracks only the watch descriptor,
+ * which is set at subscription time and never mutates over the life of
+ * the watch.
+ *
+ * The reducer uses an `if`/else shape rather than `switch`/`softAssertNever`
+ * because `ResourceWatchAction` currently has a single variant — TypeScript
+ * does not narrow single-variant discriminated unions to `never` after the
+ * sole case branch, so the usual exhaustiveness pattern would not compile.
+ * Unknown action types degrade gracefully (mirroring `softAssertNever`'s
+ * runtime behaviour) so a client speaking an older protocol stays correct
+ * if the server adds new `resourceWatch/*` actions in a future version.
+ */
+export declare function resourceWatchReducer(state: ResourceWatchState, action: ResourceWatchAction, log?: (msg: string) => void): ResourceWatchState;

package/vscode/src/vs/platform/agentHost/common/state/protocol/reducers.d.ts

@@ -0,0 +1,8 @@
+export { rootReducer } from "@codingame/monaco-vscode-chat-service-override/vscode/vs/platform/agentHost/common/state/protocol/channels-root/reducer";
+export { sessionReducer } from "@codingame/monaco-vscode-chat-service-override/vscode/vs/platform/agentHost/common/state/protocol/channels-session/reducer";
+export { chatReducer } from "@codingame/monaco-vscode-chat-service-override/vscode/vs/platform/agentHost/common/state/protocol/channels-chat/reducer";
+export { terminalReducer } from "@codingame/monaco-vscode-chat-service-override/vscode/vs/platform/agentHost/common/state/protocol/channels-terminal/reducer";
+export { changesetReducer } from "@codingame/monaco-vscode-chat-service-override/vscode/vs/platform/agentHost/common/state/protocol/channels-changeset/reducer";
+export { annotationsReducer } from "@codingame/monaco-vscode-chat-service-override/vscode/vs/platform/agentHost/common/state/protocol/channels-annotations/reducer";
+export { resourceWatchReducer } from "./channels-resource-watch/reducer.js";
+export { softAssertNever, isClientDispatchable } from "@codingame/monaco-vscode-chat-service-override/vscode/vs/platform/agentHost/common/state/protocol/common/reducer-helpers";

package/vscode/src/vs/platform/agentHost/common/state/sessionReducers.d.ts

@@ -0,0 +1,9 @@
+export { rootReducer, sessionReducer, chatReducer, changesetReducer, annotationsReducer, softAssertNever, isClientDispatchable } from "./protocol/reducers.js";
+import { type ToolKind } from "../meta/agentToolCallMeta.js";
+import type { ICompletedToolCall, ToolCallState } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionState";
+/**
+ * Extracts the VS Code-specific `toolKind` hint from a tool call's `_meta`
+ * bag. This is not part of the protocol and is injected by the agent adapter
+ * (e.g. `copilotEventMapper`).
+ */
+export declare function getToolKind(tc: ToolCallState | ICompletedToolCall): ToolKind | undefined;

package/vscode/src/vs/platform/mcp/common/modelContextProtocolApps.d.ts

@@ -5,10 +5,10 @@ type Implementation = MCP.Implementation;
 type RequestId = MCP.RequestId;
 type Tool = MCP.Tool;
 export declare namespace McpApps {
-    type AppRequest = MCP.CallToolRequest | MCP.ReadResourceRequest | MCP.PingRequest | (McpUiOpenLinkRequest & MCP.JSONRPCRequest) | (McpUiDownloadFileRequest & MCP.JSONRPCRequest) | (McpUiUpdateModelContextRequest & MCP.JSONRPCRequest) | (McpUiMessageRequest & MCP.JSONRPCRequest) | (McpUiRequestDisplayModeRequest & MCP.JSONRPCRequest) | (McpApps.McpUiInitializeRequest & MCP.JSONRPCRequest);
+    type AppRequest = MCP.CallToolRequest | MCP.ReadResourceRequest | MCP.CreateMessageRequest | MCP.PingRequest | (McpUiOpenLinkRequest & MCP.JSONRPCRequest) | (McpUiDownloadFileRequest & MCP.JSONRPCRequest) | (McpUiUpdateModelContextRequest & MCP.JSONRPCRequest) | (McpUiMessageRequest & MCP.JSONRPCRequest) | (McpUiRequestDisplayModeRequest & MCP.JSONRPCRequest) | (McpApps.McpUiInitializeRequest & MCP.JSONRPCRequest);
     type AppNotification = McpUiInitializedNotification | McpUiSizeChangedNotification | MCP.LoggingMessageNotification | CustomSandboxWheelNotification;
     type AppMessage = AppRequest | AppNotification;
-    type HostResult = MCP.CallToolResult | MCP.ReadResourceResult | MCP.EmptyResult | McpApps.McpUiInitializeResult | McpUiMessageResult | McpUiOpenLinkResult | McpUiDownloadFileResult | McpUiRequestDisplayModeResult;
+    type HostResult = MCP.CallToolResult | MCP.ReadResourceResult | MCP.CreateMessageResult | MCP.EmptyResult | McpApps.McpUiInitializeResult | McpUiMessageResult | McpUiOpenLinkResult | McpUiDownloadFileResult | McpUiRequestDisplayModeResult;
     type HostNotification = McpUiHostContextChangedNotification | McpUiResourceTeardownRequest | McpUiToolInputNotification | McpUiToolInputPartialNotification | McpUiToolResultNotification | McpUiToolCancelledNotification | McpUiSizeChangedNotification;
     type HostMessage = HostResult | HostNotification;
     /** Custom notification used for bubbling up sandbox wheel events. */