@codingame/monaco-vscode-chat-service-override 37.0.0 → 37.1.0

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

@@ -0,0 +1,114 @@
+import type { SessionModelInfo } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/state";
+import type { IAgentModelInfo } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agent";
+/**
+ * Well-known model picker metadata carried under a model's open `_meta` bag (see {@link IAgentModelInfo._meta} /
+ * {@link SessionModelInfo._meta}). Agents populate these keys so the chat model picker can render pricing,
+ * capability categories, and promotions.
+ *
+ * All cost values are expressed as credits per 1M tokens — the same unit the model picker hover renders (see
+ * `getModelHoverContent` in `modelPicker/modelPickerHover.ts`). Fields are optional; agents omit what they don't know.
+ */
+export interface IAgentModelPricingMeta {
+    /** Request multiplier (e.g. `1.5` rendered as "1.5x"). */
+    readonly multiplierNumeric?: number;
+    /** Default-tier input cost in credits per 1M tokens. */
+    readonly inputCost?: number;
+    /** Default-tier cached-input (read) cost in credits per 1M tokens. */
+    readonly cacheCost?: number;
+    /** Default-tier cache-write cost in credits per 1M tokens. */
+    readonly cacheWriteCost?: number;
+    /** Default-tier output cost in credits per 1M tokens. */
+    readonly outputCost?: number;
+    /** Long-context-tier input cost in credits per 1M tokens. */
+    readonly longContextInputCost?: number;
+    /** Long-context-tier cached-input (read) cost in credits per 1M tokens. */
+    readonly longContextCacheCost?: number;
+    /** Long-context-tier cache-write cost in credits per 1M tokens. */
+    readonly longContextCacheWriteCost?: number;
+    /** Long-context-tier output cost in credits per 1M tokens. */
+    readonly longContextOutputCost?: number;
+    /** Coarse price bucket (e.g. `low`, `medium`, `high`) for an at-a-glance tag. */
+    readonly priceCategory?: string;
+    /** Capability category (e.g. `lightweight`, `versatile`, `powerful`) shown in the model picker hover. */
+    readonly category?: string;
+    /** Whole-number percentage discount (0-100) for the synthetic `auto` model; shown as a "{n}% discount" detail. */
+    readonly discountPercent?: number;
+    /** Promotional information for the model. A `discountPercent` of `0` is a valid message-only promo. */
+    readonly promo?: {
+        readonly id: string;
+        readonly discountPercent: number;
+        /** ISO 8601 end date; absent for open-ended promotions. */
+        readonly endsAt?: string;
+        readonly message: string;
+        readonly showBanner?: boolean;
+    };
+}
+/**
+ * Reads the well-known {@link IAgentModelPricingMeta} keys from a model's open `_meta` bag, ignoring any unrelated
+ * provider-specific keys and values of the wrong type. Returns an object containing only the keys that were present
+ * with a valid value.
+ */
+export declare function readAgentModelPricingMeta(model: IAgentModelInfo | SessionModelInfo): IAgentModelPricingMeta;
+/**
+ * Builds a `_meta` payload from {@link IAgentModelPricingMeta}, dropping `undefined` entries. Returns `undefined` when
+ * no model picker fields are known so callers can avoid attaching an empty `_meta` object.
+ */
+export declare function createAgentModelPricingMeta(pricing: IAgentModelPricingMeta): Record<string, unknown> | undefined;
+/**
+ * Normalizes a raw CAPI or Copilot SDK billing payload into the camelCase
+ * {@link ICAPIModelBilling} shape that {@link createPricingMetaFromBilling} expects.
+ * Prices are converted from the payload's billing batch to credits per million tokens.
+ */
+export declare function normalizeCAPIBilling(raw: unknown): ICAPIModelBilling | undefined;
+/**
+ * Normalized model billing shape shared by CAPI-backed agents and the Copilot SDK model list.
+ * Raw snake_case and current SDK fields are converted at the read boundary by {@link normalizeCAPIBilling}.
+ */
+export interface ICAPIModelBilling {
+    readonly multiplier?: number;
+    /** Coarse price bucket surfaced as a tag in the model picker hover. */
+    readonly priceCategory?: string;
+    /** Whole-number percentage discount (0-100) for the synthetic `auto` model; rendered as a "{n}% discount" detail. */
+    readonly discountPercent?: number;
+    /** Promotional information for the model. A `discountPercent` of `0` is a valid message-only promo. */
+    readonly promo?: {
+        readonly id: string;
+        readonly discountPercent: number;
+        /** ISO 8601 end date; absent for open-ended promotions. */
+        readonly endsAt?: string;
+        readonly message: string;
+        /** Whether the promo may be surfaced as a chat input banner. Absent means eligible; only `false` suppresses it. */
+        readonly showBanner?: boolean;
+    };
+    readonly tokenPrices?: {
+        readonly contextMax?: number;
+        readonly inputPrice?: number;
+        readonly cachePrice?: number;
+        readonly cacheWritePrice?: number;
+        readonly outputPrice?: number;
+        readonly longContext?: {
+            readonly contextMax?: number;
+            readonly inputPrice?: number;
+            readonly cachePrice?: number;
+            readonly cacheWritePrice?: number;
+            readonly outputPrice?: number;
+        };
+    };
+}
+/**
+ * Converts a CAPI model's billing payload into an {@link IAgentModelPricingMeta} `_meta` bag. Long-context costs are
+ * only emitted when there is an actual surcharge (at least one long-context price differs from the default tier).
+ * When emitting, any missing long-context field falls back to the default-tier value so the hover table renders
+ * complete rows. See {@link hasLongContextSurcharge} for the surcharge detection logic.
+ *
+ * @param billing - The model's billing info, narrowed through {@link ICAPIModelBilling}.
+ * @param priceCategory - An optional override for the price category (e.g. from `modelPickerPriceCategory` on the
+ *   model object itself). Falls back to `billing.priceCategory` when not provided.
+ * @param category - The model's capability category from its top-level `modelPickerCategory` field.
+ */
+export declare function createPricingMetaFromBilling(billing: ICAPIModelBilling | undefined, priceCategory?: string, category?: string): Record<string, unknown> | undefined;
+/**
+ * Whether the model's long-context tier has any cost that differs from its default tier.
+ * Drives the context-size picker default: smaller tier when surcharged, full window when free.
+ */
+export declare function hasLongContextSurcharge(billing: ICAPIModelBilling | undefined): boolean;

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

@@ -0,0 +1,56 @@
+
+
+const NUMBER_KEYS = [
+    "multiplierNumeric",
+    "inputCost",
+    "cacheCost",
+    "cacheWriteCost",
+    "outputCost",
+    "longContextInputCost",
+    "longContextCacheCost",
+    "longContextCacheWriteCost",
+    "longContextOutputCost",
+    "discountPercent"
+];
+const COPILOT_MODEL_PICKER_CATEGORY_META_KEY = "copilot.modelPickerCategory";
+function readAgentModelPricingMeta(model) {
+    const meta = model._meta;
+    if (!meta) {
+        return {};
+    }
+    const result = {};
+    for (const key of NUMBER_KEYS) {
+        const value = meta[key];
+        if (typeof value === "number") {
+            result[key] = value;
+        }
+    }
+    if (typeof meta.priceCategory === "string") {
+        result.priceCategory = meta.priceCategory;
+    }
+    if (typeof meta.category === "string") {
+        result.category = meta.category;
+    } else if (typeof meta[COPILOT_MODEL_PICKER_CATEGORY_META_KEY] === "string") {
+        result.category = meta[COPILOT_MODEL_PICKER_CATEGORY_META_KEY];
+    }
+    const rawPromo = meta.promo;
+    if (rawPromo && typeof rawPromo === "object" && !Array.isArray(rawPromo)) {
+        const p = rawPromo;
+        if (typeof p.id === "string" && typeof p.discountPercent === "number" && typeof p.message === "string") {
+            result.promo = {
+                id: p.id,
+                discountPercent: p.discountPercent,
+                message: p.message,
+                ...(typeof p.endsAt === "string" ? {
+                    endsAt: p.endsAt
+                } : {}),
+                ...(typeof p.showBanner === "boolean" ? {
+                    showBanner: p.showBanner
+                } : {})
+            };
+        }
+    }
+    return result;
+}
+
+export { readAgentModelPricingMeta };

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

@@ -4,6 +4,9 @@ import './agentMerge.js';
 import '@codingame/monaco-vscode-katex-common/vscode/vs/platform/agentHost/common/meta/agentSystemNotificationMeta';
 import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionState';
 
+const BRANCH_CHANGESET_ID = "branch";
+const TURN_CHANGESET_PREFIX = "turn/";
+const CHANGESET_PATH_SEGMENT = "/changeset/";
 var ChangesetKind;
 (function(ChangesetKind) {
     ChangesetKind["Branch"] = "branch";
@@ -23,5 +26,16 @@ function resolveChangesetUriTemplate(sessionUri, uriTemplate) {
     }
     return `${sessionUri.replace(/\/+$/, "")}/${uriTemplate.replace(/^\/+/, "")}`;
 }
+function buildBranchChangesetUri(sessionUri) {
+    return `${sessionUri}${CHANGESET_PATH_SEGMENT}${BRANCH_CHANGESET_ID}`;
+}
+function buildTurnChangesetUri(sessionUri, turnId) {
+    if (!turnId || turnId.includes("/")) {
+        throw ( new Error(
+            `buildTurnChangesetUri: turnId must be non-empty and not contain '/' (got ${JSON.stringify(turnId)})`
+        ));
+    }
+    return `${sessionUri}${CHANGESET_PATH_SEGMENT}${TURN_CHANGESET_PREFIX}${turnId}`;
+}
 
-export { ChangesetKind, resolveChangesetUriTemplate, selectDefaultChangeset };
+export { ChangesetKind, buildBranchChangesetUri, buildTurnChangesetUri, resolveChangesetUriTemplate, selectDefaultChangeset };

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

@@ -0,0 +1,73 @@
+/**
+ * A single flattened completion form of a config-action slash command (the bare
+ * command or one of its named sub-arguments), ready to be emitted as a
+ * completion item.
+ */
+export interface ICopilotConfigSlashCommandItem {
+    /**
+     * The text inserted when accepted. Empty for a pure toggle (nothing is left
+     * in the input); `/command ` (trailing space) for an item that keeps the text
+     * so an argument can be typed.
+     */
+    readonly insertText: string;
+    /** The display label shown in the picker (e.g. `/autopilot on`). */
+    readonly label: string;
+    /** The command name (without the leading `/`). */
+    readonly command: string;
+    /** Human-readable description shown in completion detail. */
+    readonly description: string;
+    /** Argument hint (ghost text) shown after acceptance for keep-text items. */
+    readonly argumentHint?: string;
+    /** The session-config change applied when accepted. */
+    readonly applyConfig: Readonly<Record<string, string>>;
+    /** Sort key used to order completions. */
+    readonly sortText: string;
+}
+/**
+ * The set of command names that are config-action commands. Used by the send
+ * path to decide whether a leading slash command should be intercepted (applied
+ * + stripped) rather than dispatched to the runtime.
+ */
+export declare function isCopilotConfigSlashCommand(command: string): boolean;
+/**
+ * The current session-config state used to filter config-action slash command
+ * completions so only the state-changing forms are offered (e.g. `/autopilot on`
+ * is hidden while already in autopilot mode).
+ */
+export interface ICopilotConfigSlashCommandState {
+    /** The session's current `mode` axis value (e.g. `interactive` / `plan` / `autopilot`). */
+    readonly mode?: string;
+    /** The session's current `autoApprove` axis value (e.g. `default` / `autoApprove`). */
+    readonly autoApprove?: string;
+}
+/**
+ * Returns the flattened completion items (one per command form) whose command
+ * name fuzzy matches `typed` (the text after the leading `/`, case-insensitive).
+ * When `typed` is empty, all items are returned.
+ *
+ * When `state` (the session's current config values) is provided, pure toggle
+ * forms that would be a no-op are filtered out so only the state-changing forms
+ * are offered (see {@link shouldOfferOption}).
+ */
+export declare function getCopilotConfigSlashCommandItems(typed: string, state?: ICopilotConfigSlashCommandState): ICopilotConfigSlashCommandItem[];
+/**
+ * Result of resolving a config-action slash command on send.
+ */
+export interface ICopilotConfigSlashCommandSendResult {
+    /** The session-config change to (re-)apply. */
+    readonly applyConfig: Readonly<Record<string, string>>;
+    /**
+     * The prompt text that should be forwarded to the runtime after stripping the
+     * command token (and any recognized sub-argument). Empty when the command is a
+     * pure toggle with no trailing prompt.
+     */
+    readonly strippedPrompt: string;
+}
+/**
+ * Resolves a leading config-action slash command for the send path: maps the
+ * command (and any recognized `on`/`off` sub-argument) to the session-config
+ * change to apply, and returns the remaining prompt text to forward with the
+ * command token stripped. Returns `undefined` for non-config-action commands so
+ * callers fall through to their normal (runtime) handling.
+ */
+export declare function resolveCopilotConfigSlashCommandOnSend(command: string, rest: string): ICopilotConfigSlashCommandSendResult | undefined;

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

@@ -0,0 +1,141 @@
+
+import '@codingame/monaco-vscode-api/vscode/vs/base/common/filters';
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { SessionConfigKey } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/sessionConfigKeys';
+
+const AUTO_APPROVE_BYPASS = "autoApprove";
+const AUTO_APPROVE_DEFAULT = "default";
+const MODE_INTERACTIVE = "interactive";
+const MODE_PLAN = "plan";
+const MODE_AUTOPILOT = "autopilot";
+function setBypassDetail() {
+    return localize(2094, "Set permissions to bypass approvals");
+}
+function setDefaultDetail() {
+    return localize(2095, "Set permissions back to default");
+}
+function autopilotOnDetail() {
+    return localize(2096, "Switch to autopilot mode");
+}
+function exitAutopilotDetail() {
+    return localize(2097, "Switch to interactive mode");
+}
+function autopilotPromptDetail() {
+    return localize(2098, "Switch to autopilot mode with an objective");
+}
+function planPromptDetail() {
+    return localize(2099, "Create an implementation plan before coding");
+}
+function autopilotArgumentHint() {
+    return localize(2100, "objective");
+}
+function promptArgumentHint() {
+    return localize(2101, "Describe what you want to plan or research");
+}
+function getConfigSlashCommands() {
+    return [{
+        command: "yolo",
+        sortText: "z1_yolo",
+        options: [{
+            arg: "on",
+            detail: setBypassDetail(),
+            config: {
+                [SessionConfigKey.AutoApprove]: AUTO_APPROVE_BYPASS
+            }
+        }, {
+            arg: "off",
+            detail: setDefaultDetail(),
+            config: {
+                [SessionConfigKey.AutoApprove]: AUTO_APPROVE_DEFAULT
+            }
+        }]
+    }, {
+        command: "allow-all",
+        sortText: "z1_allow-all",
+        options: [{
+            arg: "on",
+            detail: setBypassDetail(),
+            config: {
+                [SessionConfigKey.AutoApprove]: AUTO_APPROVE_BYPASS
+            }
+        }, {
+            arg: "off",
+            detail: setDefaultDetail(),
+            config: {
+                [SessionConfigKey.AutoApprove]: AUTO_APPROVE_DEFAULT
+            }
+        }]
+    }, {
+        command: "autopilot",
+        sortText: "z1_autopilot",
+        options: [{
+            arg: "on",
+            detail: autopilotOnDetail(),
+            config: {
+                [SessionConfigKey.Mode]: MODE_AUTOPILOT
+            }
+        }, {
+            arg: "off",
+            detail: exitAutopilotDetail(),
+            config: {
+                [SessionConfigKey.Mode]: MODE_INTERACTIVE
+            }
+        }, {
+            detail: autopilotPromptDetail(),
+            config: {
+                [SessionConfigKey.Mode]: MODE_AUTOPILOT
+            },
+            argumentHint: autopilotArgumentHint()
+        }]
+    }, {
+        command: "plan",
+        sortText: "z1_plan",
+        options: [{
+            detail: planPromptDetail(),
+            config: {
+                [SessionConfigKey.Mode]: MODE_PLAN
+            },
+            argumentHint: promptArgumentHint()
+        }]
+    }, {
+        command: "goal",
+        sortText: "z1_goal",
+        options: [{
+            detail: planPromptDetail(),
+            config: {
+                [SessionConfigKey.Mode]: MODE_PLAN
+            },
+            argumentHint: promptArgumentHint()
+        }]
+    }];
+}
+function resolveCopilotConfigSlashCommandOnSend(command, rest) {
+    const descriptor = getConfigSlashCommands().find(c => c.command.toLowerCase() === command.toLowerCase());
+    if (!descriptor) {
+        return undefined;
+    }
+    const trimmedRest = rest.trim();
+    const namedOptions = descriptor.options.filter(o => o.arg !== undefined);
+    const baseOption = descriptor.options.find(o => o.arg === undefined);
+    if (namedOptions.length > 0 && trimmedRest.length > 0) {
+        const match = /^(\S+)(?:\s+([\s\S]*))?$/.exec(trimmedRest);
+        const firstToken = match?.[1]?.toLowerCase();
+        const matched = namedOptions.find(o => o.arg?.toLowerCase() === firstToken);
+        if (matched) {
+            return {
+                applyConfig: matched.config,
+                strippedPrompt: (match?.[2] ?? "").trim()
+            };
+        }
+        if (!baseOption) {
+            return undefined;
+        }
+    }
+    const fallback = baseOption ?? descriptor.options[0];
+    return {
+        applyConfig: fallback.config,
+        strippedPrompt: trimmedRest
+    };
+}
+
+export { resolveCopilotConfigSlashCommandOnSend };

package/vscode/src/vs/platform/agentHost/common/meta/agentCompletionAttachmentMeta.js

@@ -1,5 +1,46 @@
 
 
+function readCompletionAttachmentMeta(attachment) {
+    const meta = attachment._meta;
+    if (!meta || typeof meta !== "object" || Array.isArray(meta)) {
+        return undefined;
+    }
+    if (typeof meta["command"] === "string") {
+        const action = readCompletionActionMeta(meta["action"]);
+        return {
+            kind: "command",
+            command: meta["command"],
+            ...(meta["isSkill"] === true ? {
+                isSkill: true
+            } : {}),
+            ...(typeof meta["description"] === "string" ? {
+                description: meta["description"]
+            } : {}),
+            ...(typeof meta["argumentHint"] === "string" ? {
+                argumentHint: meta["argumentHint"]
+            } : {}),
+            ...(action ? {
+                action
+            } : {})
+        };
+    }
+    if (typeof meta["uri"] === "string") {
+        return {
+            kind: "skill",
+            uri: meta["uri"],
+            ...(typeof meta["name"] === "string" ? {
+                name: meta["name"]
+            } : {}),
+            ...(typeof meta["displayName"] === "string" ? {
+                displayName: meta["displayName"]
+            } : {}),
+            ...(typeof meta["description"] === "string" ? {
+                description: meta["description"]
+            } : {})
+        };
+    }
+    return undefined;
+}
 function getCompletionAction(meta) {
     if (!meta || typeof meta !== "object" || Array.isArray(meta)) {
         return undefined;
@@ -35,4 +76,4 @@ function getCommandArgumentHint(meta) {
     return typeof meta["argumentHint"] === "string" ? meta["argumentHint"] : undefined;
 }
 
-export { getCommandArgumentHint, getCompletionAction };
+export { getCommandArgumentHint, getCompletionAction, readCompletionAttachmentMeta };

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

@@ -0,0 +1,27 @@
+import type { AgentCustomization } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/state";
+/**
+ * Well-known typed view over a custom agent's `_meta` bag (see
+ * `AgentCustomization._meta`), populated by the host's customization discovery
+ * and read by the agents-window customization providers. Read it through
+ * {@link readAgentCustomizationMeta} rather than indexing `_meta` directly.
+ */
+export interface IAgentCustomizationMeta {
+    /**
+     * Whether the user may invoke this custom agent directly (e.g. from the
+     * agent picker). Absent is treated as `true` by convention — only an
+     * explicit `false` hides the agent from direct user invocation.
+     */
+    readonly userInvocable?: boolean;
+}
+/**
+ * Reads the well-known {@link IAgentCustomizationMeta} keys from a custom
+ * agent's `_meta` bag, dropping unknown keys and wrong-typed values.
+ */
+export declare function readAgentCustomizationMeta(agent: AgentCustomization): IAgentCustomizationMeta;
+/**
+ * Serializes a typed {@link IAgentCustomizationMeta} into the `_meta` record,
+ * dropping `undefined` entries and returning `undefined` when empty. Build a
+ * custom agent's `_meta` through this so producers stay in lock-step with
+ * {@link readAgentCustomizationMeta}.
+ */
+export declare function toAgentCustomizationMeta(meta: IAgentCustomizationMeta): Record<string, unknown> | undefined;

package/vscode/src/vs/platform/agentHost/common/meta/agentCustomizationMeta.js

@@ -0,0 +1,14 @@
+
+
+function readAgentCustomizationMeta(agent) {
+    const meta = agent._meta;
+    const result = {};
+    if (agent.disableUserInvocation === true) {
+        result.userInvocable = false;
+    } else if (typeof meta?.["userInvocable"] === "boolean") {
+        result.userInvocable = meta["userInvocable"];
+    }
+    return result;
+}
+
+export { readAgentCustomizationMeta };

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

@@ -0,0 +1,14 @@
+/** VS Code-owned request metadata indicating a throwaway chat surface. */
+export declare const VSCODE_EPHEMERAL_SESSION_META_KEY = "vscode.chat.ephemeralSession";
+interface IHasEphemeralSessionMeta {
+    readonly _meta?: Record<string, unknown>;
+}
+/** Typed view over VS Code's ephemeral-session request metadata. */
+export interface IEphemeralSessionMeta {
+    readonly isEphemeral?: boolean;
+}
+/** Reads recognized ephemeral-session metadata, dropping wrong-typed values. */
+export declare function readEphemeralSessionMeta(source: IHasEphemeralSessionMeta): IEphemeralSessionMeta;
+/** Adds VS Code's ephemeral-session metadata to an open request metadata bag. */
+export declare function withEphemeralSessionMeta(meta: Record<string, unknown> | undefined, isEphemeral: boolean | undefined): Record<string, unknown> | undefined;
+export {};

package/vscode/src/vs/platform/agentHost/common/meta/agentEphemeralSessionMeta.js

@@ -0,0 +1,11 @@
+
+
+const VSCODE_EPHEMERAL_SESSION_META_KEY = 'vscode.chat.ephemeralSession';
+function withEphemeralSessionMeta(meta, isEphemeral) {
+    if (isEphemeral === undefined) {
+        return meta;
+    }
+    return { ...(meta ?? {}), [VSCODE_EPHEMERAL_SESSION_META_KEY]: isEphemeral };
+}
+
+export { VSCODE_EPHEMERAL_SESSION_META_KEY, withEphemeralSessionMeta };

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

@@ -24,56 +24,56 @@ var AgentHostSandboxKey;
 createSchema({
     [AgentHostSandboxConfigKey.Sandbox]: schemaProperty({
         type: "object",
-        title: ( localize(2080, "Agent Sandbox")),
+        title: ( localize(2126, "Agent Sandbox")),
         properties: {
             [AgentHostSandboxKey.Enabled]: {
                 type: "string",
-                title: ( localize(2081, "Sandbox Enabled")),
+                title: ( localize(2127, "Sandbox Enabled")),
                 enum: [AgentSandboxEnabledValue.Off, AgentSandboxEnabledValue.On]
             },
             [AgentHostSandboxKey.WindowsEnabled]: {
                 type: "string",
-                title: ( localize(2082, "Sandbox Enabled (Windows)")),
+                title: ( localize(2128, "Sandbox Enabled (Windows)")),
                 enum: [AgentSandboxEnabledValue.Off, AgentSandboxEnabledValue.On]
             },
             [AgentHostSandboxKey.AllowNetwork]: {
                 type: "boolean",
-                title: ( localize(2083, "Allow Network"))
+                title: ( localize(2129, "Allow Network"))
             },
             [AgentHostSandboxKey.AllowUnsandboxedCommands]: {
                 type: "boolean",
-                title: ( localize(2084, "Allow Unsandboxed Commands"))
+                title: ( localize(2130, "Allow Unsandboxed Commands"))
             },
             [AgentHostSandboxKey.LinuxFileSystem]: {
                 type: "object",
-                title: ( localize(2085, "Linux Sandbox Filesystem"))
+                title: ( localize(2131, "Linux Sandbox Filesystem"))
             },
             [AgentHostSandboxKey.MacFileSystem]: {
                 type: "object",
-                title: ( localize(2086, "macOS Sandbox Filesystem"))
+                title: ( localize(2132, "macOS Sandbox Filesystem"))
             },
             [AgentHostSandboxKey.WindowsFileSystem]: {
                 type: "object",
-                title: ( localize(2087, "Windows Sandbox Filesystem"))
+                title: ( localize(2133, "Windows Sandbox Filesystem"))
             },
             [AgentHostSandboxKey.AdvancedRuntime]: {
                 type: "object",
-                title: ( localize(2088, "Advanced Sandbox Runtime"))
+                title: ( localize(2134, "Advanced Sandbox Runtime"))
             },
             [AgentHostSandboxKey.AllowedNetworkDomains]: {
                 type: "array",
-                title: ( localize(2089, "Allowed Network Domains")),
+                title: ( localize(2135, "Allowed Network Domains")),
                 items: {
                     type: "string",
-                    title: ( localize(2090, "Domain"))
+                    title: ( localize(2136, "Domain"))
                 }
             },
             [AgentHostSandboxKey.DeniedNetworkDomains]: {
                 type: "array",
-                title: ( localize(2091, "Denied Network Domains")),
+                title: ( localize(2137, "Denied Network Domains")),
                 items: {
                     type: "string",
-                    title: ( localize(2092, "Domain"))
+                    title: ( localize(2138, "Domain"))
                 }
             }
         }

package/vscode/src/vs/platform/agentHost/common/state/agentSubscription.js

@@ -17,7 +17,7 @@ import { automationReducer } from './protocol/channels-automation/reducer.js';
 import { automationRunReducer } from './protocol/channels-automation-run/reducer.js';
 import '@codingame/monaco-vscode-katex-common/vscode/vs/platform/agentHost/common/meta/agentPermissionRequestMeta';
 import { isAhpRootChannel, isAhpAutomationCatalogChannel, isAhpAutomationRunChannel, StateComponents } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionState';
-import { normalizeLegacyChatStateErrors } from './legacyProtocolCompatibility.js';
+import { normalizeLegacyChatStateErrors } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/legacyProtocolCompatibility';
 import { observableFromEvent } from '@codingame/monaco-vscode-api/vscode/vs/base/common/observableInternal/observables/observableFromEvent';
 
 class BaseAgentSubscription extends Disposable {

package/vscode/src/vs/platform/agentHost/common/state/sessionActions.js

@@ -3,7 +3,10 @@ export { ActionType } from '@codingame/monaco-vscode-api/vscode/vs/platform/agen
 export { AuthRequiredReason } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/common/notifications';
 
 const NotificationType = {
-    SessionRemoved: 'root/sessionRemoved'};
+    SessionRemoved: 'root/sessionRemoved',
+    Progress: 'root/progress',
+    AuthRequired: 'auth/required',
+};
 function isSessionAction(action) {
     return action.type.startsWith('session/');
 }

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

@@ -0,0 +1,4 @@
+/** Runtime/model-facing override name. */
+export declare const RUNTIME_TOOL_SEARCH_TOOL_NAME = "tool_search_tool";
+/** Client/workbench-facing tool reference name. */
+export declare const CLIENT_TOOL_SEARCH_REFERENCE_NAME = "toolSearch";

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

@@ -0,0 +1,6 @@
+
+
+const RUNTIME_TOOL_SEARCH_TOOL_NAME = 'tool_search_tool';
+const CLIENT_TOOL_SEARCH_REFERENCE_NAME = 'toolSearch';
+
+export { CLIENT_TOOL_SEARCH_REFERENCE_NAME, RUNTIME_TOOL_SEARCH_TOOL_NAME };

package/vscode/src/vs/platform/networkFilter/common/networkFilterService.js

@@ -61,7 +61,7 @@ let AgentNetworkFilterService = class AgentNetworkFilterService extends Disposab
     formatError(uri) {
         const domain = extractDomainFromUri(uri);
         return localize(
-            2363,
+            2409,
             "Access to {0} is blocked by network domain policy (see `{1}` and `{2}` settings).",
             domain ?? uri.authority,
             AgentNetworkDomainSettingId.AllowedNetworkDomains,