@codingame/monaco-vscode-api 36.2.7 → 37.1.0

package/vscode/src/vs/platform/agentHost/common/state/protocol/channels-chat/actions.d.ts

@@ -1,6 +1,7 @@
 import { ActionType } from "../common/actions.js";
-import type { StringOrMarkdown, ErrorInfo, FileEdit, UsageInfo } from "../common/state.js";
-import { ToolCallConfirmationReason, ToolCallCancellationReason, PendingMessageKind, type Message, type ResponsePart, type ToolCallResult, type ToolResultContent, type ChatInputAnswer, type ChatInputRequest, type ChatInputResponseKind, type ConfirmationOption, type ToolCallContributor } from "./state.js";
+import type { StringOrMarkdown, FileEdit, UsageInfo, URI } from "../common/state.js";
+import type { McpAuthRequirement } from "../channels-session/state.js";
+import { ToolCallConfirmationReason, ToolCallCancellationReason, PendingMessageKind, type Message, type ResponsePart, type ToolCallResult, type ToolResultContent, type ChatInputAnswer, type ChatInputRequest, type ChatInputResponseKind, type ConfirmationOption, type ErrorResponsePart, type ToolCallContributor, type ToolCallRiskAssessment, type ToolInput, type Turn } from "./state.js";
 /**
  * Base interface for all tool-call-scoped actions, carrying the common turn
  * and tool call identifiers. The owning chat URI is identified by the
@@ -36,6 +37,8 @@ export interface ChatTurnStartedAction {
     type: ActionType.ChatTurnStarted;
     /** Turn identifier */
     turnId: string;
+    /** ISO 8601 timestamp when this turn started. */
+    startedAt: string;
     /** The new message */
     message: Message;
     /** If this turn was auto-started from a queued message, the ID of that message */
@@ -55,7 +58,7 @@ export interface ChatTurnStartedAction {
  * Streaming text chunk from the assistant, appended to a specific response part.
  *
  * The server MUST first emit a `chat/responsePart` to create the target
- * part (markdown or reasoning), then use this action to append text to it.
+ * markdown part, then use this action to append text to it.
  *
  * @category Chat Actions
  * @version 1
@@ -82,6 +85,9 @@ export interface ChatDeltaAction {
 /**
  * Structured content appended to the response.
  *
+ * An {@link ErrorResponsePart} MUST be appended with {@link ChatErrorAction}
+ * instead so adding the part and ending the turn are one atomic transition.
+ *
  * @category Chat Actions
  * @version 1
  */
@@ -89,7 +95,7 @@ export interface ChatResponsePartAction {
     type: ActionType.ChatResponsePart;
     /** Turn identifier */
     turnId: string;
-    /** Response part (markdown or content ref) */
+    /** Response part to append; error parts are ignored. */
     part: ResponsePart;
     /**
      * Additional provider-specific metadata for this action.
@@ -136,8 +142,8 @@ export interface ChatToolCallStartAction extends ToolCallActionBase {
  */
 export interface ChatToolCallDeltaAction extends ToolCallActionBase {
     type: ActionType.ChatToolCallDelta;
-    /** Partial parameter content to append */
-    content: string;
+    /** Partial parameter content to append, if provided by the host. */
+    content?: string;
     /** Updated progress message */
     invocationMessage?: StringOrMarkdown;
 }
@@ -161,12 +167,24 @@ export interface ChatToolCallDeltaAction extends ToolCallActionBase {
  */
 export interface ChatToolCallReadyAction extends ToolCallActionBase {
     type: ActionType.ChatToolCallReady;
+    /**
+     * Final contributor metadata. MUST NOT change execution ownership established
+     * at `chat/toolCallStart`; a client contributor must keep the same `clientId`.
+     */
+    contributor?: ToolCallContributor;
+    /**
+     * Final human-readable description of what the tool invocation intends to do.
+     * When present, replaces the provisional intention from `chat/toolCallStart`.
+     */
+    intention?: string;
     /** Message describing what the tool will do or what confirmation is needed */
     invocationMessage: StringOrMarkdown;
-    /** Raw tool input */
-    toolInput?: string;
+    /** Final tool input */
+    toolInput?: ToolInput;
     /** Short title for the confirmation prompt (e.g. `"Run in terminal"`, `"Write file"`) */
     confirmationTitle?: StringOrMarkdown;
+    /** Risk assessment that informed the confirmation requirement. */
+    riskAssessment?: ToolCallRiskAssessment;
     /** File edits that this tool call will perform, for preview before confirmation */
     edits?: {
         items: FileEdit[];
@@ -196,7 +214,13 @@ export interface ChatToolCallApprovedAction extends ToolCallActionBase {
     approved: true;
     /** How the tool was confirmed */
     confirmed: ToolCallConfirmationReason;
-    /** Edited tool input parameters, if the client modified them before confirming */
+    /**
+     * Edited tool input parameters, if the client modified them before confirming.
+     *
+     * For inline `toolInput`, the reducer replaces the state value directly.
+     * For referenced input, the host MUST replace the resource contents before
+     * echoing the accepted action.
+     */
     editedToolInput?: string;
     /** ID of the selected confirmation option, if the server provided options */
     selectedOptionId?: string;
@@ -245,6 +269,22 @@ export type ChatToolCallConfirmedAction = ChatToolCallApprovedAction | ChatToolC
  * if the implementing client disconnects or becomes unresponsive, and dispatch
  * this action with `result.success = false` and an appropriate error.
  *
+ * A client MAY also dispatch this action with a **failed** result (
+ * `result.success: false`) for a tool call currently in `auth-required`
+ * status, to cancel that invocation without completing the pending MCP
+ * authentication challenge. This always transitions the tool call straight
+ * to `completed`, preserving the fields it had before pausing for auth;
+ * `requiresResultConfirmation` is ignored for this transition; the
+ * cancellation can never enter `pending-result-confirmation`, since there is
+ * no real result to review.
+ *
+ * A **successful** result (`result.success: true`) is invalid for a tool
+ * call in `auth-required` status — execution never resumed after the
+ * challenge, so there's nothing that could have produced it. The reducer
+ * MUST reject/ignore it as a no-op, leaving the tool call in
+ * `auth-required`. The client must resolve the auth challenge
+ * (`chat/toolCallAuthResolved`) before completing successfully.
+ *
  * @category Chat Actions
  * @version 1
  * @clientDispatchable
@@ -292,6 +332,44 @@ export interface ChatToolCallContentChangedAction extends ToolCallActionBase {
     /** The current partial content for the running tool call */
     content: ToolResultContent[];
 }
+/**
+ * A running tool call is paused pending MCP authentication. Transitions the
+ * tool call from `running` to `auth-required`.
+ *
+ * The server dispatches this when the MCP server backing the call responds
+ * with a 401/403 challenge mid-execution (see
+ * {@link McpAuthRequirement.reason | `insufficientScope`}). The host SHOULD
+ * pair this with `session/inputNeededSet` (kind `toolAuthentication`) so the
+ * block is visible at the session-summary level, mirroring
+ * {@link McpServerAuthRequiredState}'s own `InputNeeded` guidance.
+ *
+ * Only valid for tool calls contributed by an MCP server — the reducer is a
+ * no-op if the tool call's `contributor` is not
+ * {@link ToolCallContributorKind.MCP | MCP-kind}.
+ *
+ * @category Chat Actions
+ * @version 1
+ */
+export interface ChatToolCallAuthRequiredAction extends ToolCallActionBase {
+    type: ActionType.ChatToolCallAuthRequired;
+    /** The authentication challenge blocking this invocation. */
+    auth: McpAuthRequirement;
+}
+/**
+ * The authentication challenge blocking a tool call has been resolved (the
+ * client pushed a token via `authenticate` and the host validated it).
+ * Transitions the tool call from `auth-required` back to `running`,
+ * preserving the fields it had before pausing.
+ *
+ * The host SHOULD remove the corresponding `session/inputNeededSet` entry
+ * (kind `toolAuthentication`) once this is dispatched.
+ *
+ * @category Chat Actions
+ * @version 1
+ */
+export interface ChatToolCallAuthResolvedAction extends ToolCallActionBase {
+    type: ActionType.ChatToolCallAuthResolved;
+}
 /**
  * Turn finished — the assistant is idle.
  *
@@ -302,6 +380,13 @@ export interface ChatTurnCompleteAction {
     type: ActionType.ChatTurnComplete;
     /** Turn identifier */
     turnId: string;
+    /**
+     * Elapsed turn duration in milliseconds, measured by the producer's own
+     * clock. Clients MUST NOT derive this by subtracting timestamps — cross-
+     * client clocks may differ — and MUST treat it as opaque, producer-supplied
+     * data.
+     */
+    duration: number;
     /**
      * Additional provider-specific metadata for this action.
      *
@@ -324,6 +409,13 @@ export interface ChatTurnCancelledAction {
     type: ActionType.ChatTurnCancelled;
     /** Turn identifier */
     turnId: string;
+    /**
+     * Elapsed turn duration in milliseconds, measured by the producer's own
+     * clock. Clients MUST NOT derive this by subtracting timestamps — cross-
+     * client clocks may differ — and MUST treat it as opaque, producer-supplied
+     * data.
+     */
+    duration: number;
     /**
      * Additional provider-specific metadata for this action.
      *
@@ -345,8 +437,18 @@ export interface ChatErrorAction {
     type: ActionType.ChatError;
     /** Turn identifier */
     turnId: string;
-    /** Error details */
-    error: ErrorInfo;
+    /**
+     * Elapsed turn duration in milliseconds, measured by the producer's own
+     * clock. Clients MUST NOT derive this by subtracting timestamps — cross-
+     * client clocks may differ — and MUST treat it as opaque, producer-supplied
+     * data.
+     */
+    duration: number;
+    /**
+     * Error part to append to the response stream before finalizing the turn.
+     * Its optional `resumable` flag indicates whether the turn can be resumed.
+     */
+    part: ErrorResponsePart;
     /**
      * Additional provider-specific metadata for this action.
      *
@@ -358,6 +460,23 @@ export interface ChatErrorAction {
      */
     _meta?: Record<string, unknown>;
 }
+/**
+ * Resumes the latest errored turn without adding another message.
+ *
+ * The turn MUST be the latest turn, its state MUST be `error`, and its final
+ * response part MUST be a resumable error. The reducer reopens the same turn
+ * with its existing message, response parts, and usage intact. The host then
+ * resumes the provider's execution for that turn.
+ *
+ * @category Chat Actions
+ * @version 1
+ * @clientDispatchable
+ */
+export interface ChatTurnResumeAction {
+    type: ActionType.ChatTurnResume;
+    /** Identifier of the errored turn. */
+    turnId: string;
+}
 /**
  * The activity description of this chat changed.
  *
@@ -375,6 +494,43 @@ export interface ChatActivityChangedAction {
     /** Human-readable description of current activity; omit or set `undefined` to clear */
     activity?: string;
 }
+/**
+ * A working directory was added to this chat's
+ * {@link ChatState.workingDirectories} subset.
+ *
+ * Membership semantics keyed by the directory URI: the reducer appends
+ * `directory` when the chat's subset does not already contain it (creating the
+ * subset if absent) and is a no-op when it is already present. `directory` MUST
+ * be one of the owning session's {@link SessionState.workingDirectories}; a host
+ * MUST reject a directory that is not. Only valid when the agent advertises
+ * {@link AgentCapabilities.multipleWorkingDirectories}.
+ *
+ * @category Chat Actions
+ * @version 1
+ * @clientDispatchable
+ */
+export interface ChatWorkingDirectorySetAction {
+    type: ActionType.ChatWorkingDirectorySet;
+    /** The working directory to add to this chat's subset. */
+    directory: URI;
+}
+/**
+ * A working directory was removed from this chat's
+ * {@link ChatState.workingDirectories} subset.
+ *
+ * Removes `directory` from the chat's subset; a no-op when it is not present.
+ * Idempotent, mirroring `session/workingDirectoryRemoved`. Only affects the
+ * chat's subset — the directory remains in the session's set.
+ *
+ * @category Chat Actions
+ * @version 1
+ * @clientDispatchable
+ */
+export interface ChatWorkingDirectoryRemovedAction {
+    type: ActionType.ChatWorkingDirectoryRemoved;
+    /** The working directory to remove from this chat's subset. */
+    directory: URI;
+}
 /**
  * Token usage report for a turn.
  *
@@ -446,6 +602,25 @@ export interface ChatTruncatedAction {
     /** Keep turns up to and including this turn. Omit to clear all turns. */
     turnId?: string;
 }
+/**
+ * Loads older completed turns into this chat's state.
+ *
+ * Hosts dispatch this before responding to `fetchTurns`, and before applying
+ * any operation that references a turn older than the currently loaded window.
+ * `turns` is ordered oldest-first and is prepended to the current `turns`
+ * window. `turnsNextCursor` replaces the state's cursor; omit it when all
+ * retained turns are now loaded.
+ *
+ * @category Chat Actions
+ * @version 1
+ */
+export interface ChatTurnsLoadedAction {
+    type: ActionType.ChatTurnsLoaded;
+    /** Older completed turns loaded into the state, ordered oldest-first. */
+    turns: Turn[];
+    /** Opaque cursor for loading the next older page, if one remains. */
+    turnsNextCursor?: string;
+}
 /**
  * A pending message was set (upsert semantics: creates or replaces).
  *
@@ -531,9 +706,9 @@ export interface ChatDraftChangedAction {
 /**
  * A session requested input from the user.
  *
- * Full-request upsert semantics: the `request` replaces any existing request
- * with the same `id`, or is appended if it is new. Answer drafts are preserved
- * unless `request.answers` is provided.
+ * Creates an unresolved {@link InputRequestResponsePart} in the active turn,
+ * or replaces the unresolved part with the same request `id`. Answer drafts
+ * are preserved unless `request.answers` is provided.
  *
  * @category Chat Actions
  * @version 1
@@ -562,10 +737,11 @@ export interface ChatInputAnswerChangedAction {
     answer?: ChatInputAnswer;
 }
 /**
- * A client accepted, declined, or cancelled a session input request.
+ * A client submitted an accept, decline, or cancel response to an input request.
  *
  * If accepted, the server uses `answers` (when provided) plus the request's
- * synced answer state to resume the blocked operation.
+ * synced answer state to resume the blocked operation. The reducer records the
+ * response and final answers on the existing {@link InputRequestResponsePart}.
  *
  * @category Chat Actions
  * @version 1
@@ -580,5 +756,5 @@ export interface ChatInputCompletedAction {
     /** Optional final answer replacement, keyed by question ID */
     answers?: Record<string, ChatInputAnswer>;
 }
-export type ChatAction = ChatTurnStartedAction | ChatDeltaAction | ChatResponsePartAction | ChatToolCallStartAction | ChatToolCallDeltaAction | ChatToolCallReadyAction | ChatToolCallConfirmedAction | ChatToolCallCompleteAction | ChatToolCallResultConfirmedAction | ChatToolCallContentChangedAction | ChatTurnCompleteAction | ChatTurnCancelledAction | ChatErrorAction | ChatActivityChangedAction | ChatUsageAction | ChatReasoningAction | ChatTruncatedAction | ChatPendingMessageSetAction | ChatPendingMessageRemovedAction | ChatQueuedMessagesReorderedAction | ChatDraftChangedAction | ChatInputRequestedAction | ChatInputAnswerChangedAction | ChatInputCompletedAction;
+export type ChatAction = ChatTurnStartedAction | ChatDeltaAction | ChatResponsePartAction | ChatToolCallStartAction | ChatToolCallDeltaAction | ChatToolCallReadyAction | ChatToolCallConfirmedAction | ChatToolCallCompleteAction | ChatToolCallResultConfirmedAction | ChatToolCallContentChangedAction | ChatToolCallAuthRequiredAction | ChatToolCallAuthResolvedAction | ChatTurnCompleteAction | ChatTurnCancelledAction | ChatErrorAction | ChatTurnResumeAction | ChatActivityChangedAction | ChatWorkingDirectorySetAction | ChatWorkingDirectoryRemovedAction | ChatUsageAction | ChatReasoningAction | ChatTruncatedAction | ChatTurnsLoadedAction | ChatPendingMessageSetAction | ChatPendingMessageRemovedAction | ChatQueuedMessagesReorderedAction | ChatDraftChangedAction | ChatInputRequestedAction | ChatInputAnswerChangedAction | ChatInputCompletedAction;
 export {};

package/vscode/src/vs/platform/agentHost/common/state/protocol/channels-chat/commands.d.ts

@@ -1,15 +1,64 @@
 import type { URI } from "../common/state.js";
 import type { BaseParams } from "../common/commands.js";
-import type { Message } from "./state.js";
+import type { Message, SideChatSelection } from "./state.js";
 /**
- * Identifies a source chat and turn to fork from.
+ * How a new chat uses its source chat and turn.
+ * @nonexhaustive
  */
-export interface ChatForkSource {
-    /** URI of the existing chat to fork from */
+export declare enum ChatSourceKind {
+    /** Copy source history through the referenced turn into the new chat. */
+    Fork = "fork",
+    /** Supply source context without copying it into the new chat's visible history. */
+    SideChat = "sideChat"
+}
+/**
+ * Copies source history through a completed turn into the new chat.
+ */
+export interface ForkChatSource {
+    /** Discriminant */
+    kind: ChatSourceKind.Fork;
+    /** URI of the existing source chat. */
+    chat: URI;
+    /**
+     * Completed turn identifier in the source chat.
+     *
+     * Content through this turn is copied into the new chat's visible `turns`.
+     */
+    turnId: string;
+}
+/**
+ * Supplies source context to a new side chat without copying it into the side
+ * chat's visible history.
+ */
+export interface SideChatSource {
+    /** Discriminant */
+    kind: ChatSourceKind.SideChat;
+    /** URI of the existing source chat. */
     chat: URI;
-    /** Turn ID in the source chat; content up to and including this turn's response is copied */
+    /**
+     * Stable source-turn identifier in the source chat.
+     *
+     * Hosts resolve this id against the source chat's current `activeTurn` or its
+     * retained `turns` when accepting `createChat`. If it names the current
+     * active turn, the host snapshots the source chat's retained history plus
+     * that turn's current user message and any partial assistant response already
+     * available. Once that turn later becomes historical, it is still referenced
+     * by this same identifier.
+     */
     turnId: string;
+    /**
+     * Optional immutable selected-text snapshot to carry into the created side
+     * chat's origin.
+     *
+     * When present, the host MUST snapshot and preserve this exact selection when
+     * it accepts `createChat`; later source-turn deltas do not alter it.
+     */
+    selection?: SideChatSelection;
 }
+/**
+ * Identifies a source chat for a new chat.
+ */
+export type ChatSource = ForkChatSource | SideChatSource;
 /**
  * Creates a new chat within a session.
  *
@@ -26,8 +75,34 @@ export interface CreateChatParams extends BaseParams {
     chat: URI;
     /** Optional initial message for the new chat. */
     initialMessage?: Message;
-    /** Optional source chat and turn to fork from. */
-    source?: ChatForkSource;
+    /**
+     * Optional source chat and source turn.
+     *
+     * The source chat MUST belong to this session. Clients MUST only request
+     * `kind: "fork"` when the selected agent advertises
+     * `capabilities.multipleChats.fork`, and `kind: "sideChat"` when the
+     * selected agent advertises `capabilities.multipleChats.sideChat`. Both
+     * source forms carry a stable top-level `turnId`. Forks target completed
+     * turns. Side chats also carry a stable `turnId`, which the host resolves
+     * against the source chat's current active turn or retained history. If it
+     * resolves to the active turn, the host snapshots the currently available
+     * partial response when accepting `createChat`. When
+     * `source.kind === "sideChat"` and `source.selection` is present, the host
+     * also snapshots and preserves that exact selected text in the created chat's
+     * origin; any `responsePartId` there is provenance only, not a live range.
+     */
+    source?: ChatSource;
+    /**
+     * Initial working-directory subset for this chat. Every entry MUST be
+     * present in the owning session's `workingDirectories`; the server MUST
+     * reject any entry that is not. When absent, the chat inherits the full
+     * session set. Forked chats (those whose `source.kind` is `"fork"`) inherit
+     * the source chat's `workingDirectories`; this field is ignored for forks.
+     *
+     * A client MUST NOT supply this field unless the agent advertises
+     * {@link AgentCapabilities.multipleWorkingDirectories}.
+     */
+    workingDirectories?: URI[];
 }
 /**
  * Disposes a chat and cleans up server-side resources.

package/vscode/src/vs/platform/agentHost/common/state/protocol/channels-chat/commands.js

@@ -0,0 +1,9 @@
+
+
+var ChatSourceKind;
+(function (ChatSourceKind) {
+    ChatSourceKind["Fork"] = "fork";
+    ChatSourceKind["SideChat"] = "sideChat";
+})(ChatSourceKind || (ChatSourceKind = {}));
+
+export { ChatSourceKind };