@codingame/monaco-vscode-api 36.2.6 → 37.0.0

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

@@ -1,5 +1,5 @@
 import type { ModelSelection } from "../channels-root/state.js";
-import type { AgentSelection, SessionStatus } from "../channels-session/state.js";
+import type { AgentSelection, McpAuthRequirement, SessionStatus } from "../channels-session/state.js";
 import type { ContentRef, ErrorInfo, FileEdit, StringOrMarkdown, TextRange, TextSelection, URI, UsageInfo } from "../common/state.js";
 /**
  * Full state for a single chat, loaded when a client subscribes to the chat's
@@ -38,25 +38,36 @@ export interface ChatState {
      */
     interactivity?: ChatInteractivity;
     /**
-     * Optional per-chat working directory.
+     * The subset of the session's
+     * {@link SessionState.workingDirectories | `workingDirectories`} that this
+     * chat's agent has tool access to. Every entry MUST be present in the owning
+     * session's `workingDirectories`; servers MUST reject a
+     * `chat/workingDirectorySet` action that violates this constraint.
      *
-     * If absent, the chat inherits
-     * {@link SessionState.workingDirectory | the session's working directory}.
-     * Hosts MAY override this for individual chats — for example, to give a
-     * subordinate chat its own git worktree so multiple chats in a session can
-     * make independent edits that the orchestrator later merges back.
+     * When absent, the chat inherits the full session set. When present but empty
+     * (not recommended), the chat has no working-directory tool access at all.
+     *
+     * Dispatch `chat/workingDirectorySet` / `chat/workingDirectoryRemoved` to
+     * update the subset on a running chat.
      */
-    workingDirectory?: URI;
+    workingDirectories?: URI[];
     /** Completed turns */
     turns: Turn[];
+    /**
+     * Cursor for loading older completed turns into this chat state.
+     *
+     * Presence means `turns` is a tail window and more historical turns are
+     * available. Pass this opaque cursor to `fetchTurns`; the host MUST insert
+     * the loaded turns into state and update or clear this cursor before
+     * responding. Absence means the state contains all retained turns.
+     */
+    turnsNextCursor?: string;
     /** Currently in-progress turn */
     activeTurn?: ActiveTurn;
     /** Message to inject into the current turn at a convenient point */
     steeringMessage?: PendingMessage;
     /** Messages to send automatically as new turns after the current turn finishes */
     queuedMessages?: PendingMessage[];
-    /** Requests for user input that are currently blocking or informing chat progress */
-    inputRequests?: ChatInputRequest[];
     /**
      * The user's in-progress draft input for this chat — the message they are
      * composing but have not sent yet, including its
@@ -105,31 +116,70 @@ export interface ChatSummary {
      */
     interactivity?: ChatInteractivity;
     /**
-     * Optional per-chat working directory.
-     *
-     * If absent, the chat inherits
-     * {@link SessionSummary.workingDirectory | the session's working directory}.
-     * See {@link ChatState.workingDirectory} for usage notes.
+     * The subset of the session's working directories this chat uses.
+     * See {@link ChatState.workingDirectories} for the full semantics.
      */
-    workingDirectory?: URI;
+    workingDirectories?: URI[];
 }
 /**
  * Discriminant for {@link ChatOrigin} — how a chat came into existence.
  *
  * @category Chat State
+ * @nonexhaustive
  */
 export declare enum ChatOriginKind {
     /** User created the chat explicitly (e.g. via the host UI). */
     User = "user",
     /** Forked from an existing chat at a specific turn. */
     Fork = "fork",
+    /** Created as an independent side conversation from a specific turn. */
+    SideChat = "sideChat",
     /** Spawned by a tool call running in another chat (e.g. a sub-agent delegation). */
     Tool = "tool"
 }
+/**
+ * Immutable selected-text snapshot captured when a side chat is created.
+ *
+ * The host records this exact text when it accepts `createChat`; later changes
+ * to the source chat do not alter it.
+ *
+ * @category Chat State
+ */
+export interface SideChatSelection {
+    /**
+     * Exact selected-text snapshot captured at `createChat` acceptance.
+     *
+     * MUST be non-empty.
+     */
+    text: string;
+    /**
+     * Optional provenance for the response part that contained {@link text} when
+     * the host took the snapshot.
+     *
+     * Advisory only: this is not a live range or offset and MUST NOT be used to
+     * recompute `text`.
+     */
+    responsePartId?: string;
+}
 /**
  * How a chat came into existence. Clients MAY use it to render
  * contextual UI (parent indicators, fork markers, "spawned by tool" badges).
  *
+ * Fork and side-chat origins both carry a stable top-level `turnId` alongside
+ * their discriminated `kind` value instead of snapshotting whether that turn
+ * was active or historical at creation time. Consumers resolve the identifier
+ * against the
+ * source chat's current `activeTurn` or retained `turns` as needed.
+ *
+ * When a host accepts side-chat creation from the source chat's current active
+ * turn, it snapshots the retained history plus that turn's current user
+ * message and any partial assistant response already available. Later
+ * source-turn deltas do not retroactively change the created side chat's
+ * starting context, and once the source turn completes it is still referenced
+ * by the same `turnId`. Side-chat origins MAY also retain an immutable
+ * {@link SideChatSelection | selected-text snapshot} captured at acceptance
+ * time; any `responsePartId` there is provenance only, not a range.
+ *
  * The `tool` variant records a tool-spawned worker from the worker's side: its
  * `chat`/`toolCallId` identify the spawning tool call in the parent chat. This
  * is the canonical record of the spawn relationship. The same edge is surfaced
@@ -144,6 +194,11 @@ export type ChatOrigin = {
     kind: ChatOriginKind.Fork;
     chat: URI;
     turnId: string;
+} | {
+    kind: ChatOriginKind.SideChat;
+    chat: URI;
+    turnId: string;
+    selection?: SideChatSelection;
 } | {
     kind: ChatOriginKind.Tool;
     chat: URI;
@@ -162,6 +217,7 @@ export type ChatOrigin = {
  * the UI uses it to show appropriate controls.
  *
  * @category Chat State
+ * @exhaustive
  */
 export declare enum ChatInteractivity {
     /** User can send messages and watch (default when absent) */
@@ -175,6 +231,7 @@ export declare enum ChatInteractivity {
  * Discriminant for pending message kinds.
  *
  * @category Pending Message Types
+ * @exhaustive
  */
 export declare enum PendingMessageKind {
     /** Injected into the current turn at a convenient point */
@@ -201,6 +258,7 @@ export interface PendingMessage {
  * How a client completed an input request.
  *
  * @category Chat Input Types
+ * @exhaustive
  */
 export declare enum ChatInputResponseKind {
     Accept = "accept",
@@ -211,6 +269,7 @@ export declare enum ChatInputResponseKind {
  * Question/input control kind.
  *
  * @category Chat Input Types
+ * @nonexhaustive
  */
 export declare enum ChatInputQuestionKind {
     Text = "text",
@@ -309,11 +368,11 @@ export interface ChatInputMultiSelectQuestion extends ChatInputQuestionBase {
  */
 export type ChatInputQuestion = ChatInputTextQuestion | ChatInputNumberQuestion | ChatInputBooleanQuestion | ChatInputSingleSelectQuestion | ChatInputMultiSelectQuestion;
 /**
- * A live request for user input.
+ * The request payload carried by an {@link InputRequestResponsePart}.
  *
- * The server creates or replaces requests with `chat/inputRequested`.
- * Clients sync drafts with `chat/inputAnswerChanged` and complete requests
- * with `chat/inputCompleted`.
+ * The server creates or replaces the containing response part with
+ * `chat/inputRequested`. Clients sync drafts with `chat/inputAnswerChanged`
+ * and submit responses with `chat/inputCompleted`.
  *
  * @category Chat Input Types
  */
@@ -333,6 +392,7 @@ export interface ChatInputRequest {
  * Answer value kind.
  *
  * @category Chat Input Types
+ * @nonexhaustive
  */
 export declare enum ChatInputAnswerValueKind {
     Text = "text",
@@ -388,6 +448,7 @@ export interface ChatInputSkipped {
  * Answer lifecycle state.
  *
  * @category Chat Input Types
+ * @exhaustive
  */
 export declare enum ChatInputAnswerState {
     Draft = "draft",
@@ -404,6 +465,7 @@ export type ChatInputAnswer = ChatInputAnswered | ChatInputSkipped;
  * How a turn ended.
  *
  * @category Turn Types
+ * @exhaustive
  */
 export declare enum TurnState {
     Complete = "complete",
@@ -414,6 +476,7 @@ export declare enum TurnState {
  * Discriminant for {@link MessageAttachment} variants.
  *
  * @category Turn Types
+ * @nonexhaustive
  */
 export declare enum MessageAttachmentKind {
     /** A simple, opaque attachment whose representation is described by the producer. */
@@ -423,7 +486,9 @@ export declare enum MessageAttachmentKind {
     /** An attachment that references a resource by URI. */
     Resource = "resource",
     /** An attachment that references annotations on an annotations channel. */
-    Annotations = "annotations"
+    Annotations = "annotations",
+    /** An attachment that references a bounded transcript from another chat. */
+    Chat = "chat"
 }
 /**
  * A completed request/response cycle.
@@ -433,6 +498,10 @@ export declare enum MessageAttachmentKind {
 export interface Turn {
     /** Turn identifier */
     id: string;
+    /** ISO 8601 timestamp when this turn started. */
+    startedAt?: string;
+    /** Turn duration in milliseconds. */
+    duration?: number;
     /** The message that initiated the turn */
     message: Message;
     /**
@@ -446,8 +515,6 @@ export interface Turn {
     usage: UsageInfo | undefined;
     /** How the turn ended */
     state: TurnState;
-    /** Error details if state is `'error'` */
-    error?: ErrorInfo;
 }
 /**
  * An in-progress turn — the assistant is actively streaming.
@@ -457,6 +524,8 @@ export interface Turn {
 export interface ActiveTurn {
     /** Turn identifier */
     id: string;
+    /** ISO 8601 timestamp when this turn started. */
+    startedAt: string;
     /** The message that initiated the turn */
     message: Message;
     /**
@@ -472,6 +541,7 @@ export interface ActiveTurn {
  * Discriminant for {@link MessageOrigin} — identifies who produced a message.
  *
  * @category Turn Types
+ * @nonexhaustive
  */
 export declare enum MessageKind {
     /** Sent directly by the user. */
@@ -486,6 +556,8 @@ export declare enum MessageKind {
      * worker chat whose first message carries a seed prompt.
      */
     Tool = "tool",
+    /** Emitted automatically when an automation run starts a session. */
+    Automation = "automation",
     /** A system-generated notification rather than a direct user message. */
     SystemNotification = "systemNotification"
 }
@@ -502,7 +574,8 @@ export interface MessageOrigin {
 }
 /**
  * A message that initiates or steers a turn. Messages can originate from the
- * user, the agent, a tool, or be system-generated (see {@link MessageOrigin}).
+ * user, the agent, a tool, an automation, or be system-generated (see
+ * {@link MessageOrigin}).
  *
  * Attachments MAY be referenced inside {@link Message.text} via their
  * {@link MessageAttachmentBase.range} field. Attachments without a range are
@@ -665,23 +738,61 @@ export interface MessageAnnotationsAttachment extends MessageAttachmentBase {
      */
     annotationIds?: string[];
 }
+/**
+ * An attachment that references a chat transcript through a fixed completed
+ * turn.
+ *
+ * The referenced chat MAY belong to a different session than the message's
+ * chat. The attachment's model representation identifies the chat in a way
+ * that hosts can resolve regardless of the session that owns it.
+ *
+ * When `endTurn` is omitted, the host MUST resolve and pin the referenced
+ * chat's latest completed turn when accepting the message. This lets clients
+ * attach a chat without knowing its turn identifiers. When provided, `endTurn`
+ * MUST reference a completed, retained turn. The host resolves the transcript
+ * from its first retained turn through the pinned turn, inclusive. Later turns
+ * do not change the context represented by an already-sent attachment.
+ *
+ * When the referenced chat has no completed retained turns, the resolved
+ * transcript is empty and hosts MUST NOT reject the attachment on that basis.
+ *
+ * Hosts MUST NOT recursively expand chat attachments found inside the
+ * referenced transcript. Clients SHOULD keep rendering `label` if the
+ * referenced chat is later pruned, and treat opening `resource` as best-effort.
+ *
+ * @category Turn Types
+ */
+export interface MessageChatAttachment extends MessageAttachmentBase {
+    /** Discriminant */
+    type: MessageAttachmentKind.Chat;
+    /** URI of the referenced chat. */
+    resource: URI;
+    /**
+     * Last completed turn included in the referenced transcript. When omitted,
+     * the host pins the latest completed turn when accepting the message.
+     */
+    endTurn?: string;
+}
 /**
  * An attachment associated with a {@link Message}.
  *
  * @category Turn Types
  */
-export type MessageAttachment = SimpleMessageAttachment | MessageEmbeddedResourceAttachment | MessageResourceAttachment | MessageAnnotationsAttachment;
+export type MessageAttachment = SimpleMessageAttachment | MessageEmbeddedResourceAttachment | MessageResourceAttachment | MessageAnnotationsAttachment | MessageChatAttachment;
 /**
  * Discriminant for response part types.
  *
  * @category Response Parts
+ * @nonexhaustive
  */
 export declare enum ResponsePartKind {
     Markdown = "markdown",
     ContentRef = "contentRef",
     ToolCall = "toolCall",
     Reasoning = "reasoning",
-    SystemNotification = "systemNotification"
+    SystemNotification = "systemNotification",
+    InputRequest = "inputRequest",
+    Error = "error"
 }
 /**
  * @category Response Parts
@@ -699,7 +810,7 @@ export interface MarkdownResponsePart {
  *
  * @category Response Parts
  */
-export interface ResourceReponsePart extends ContentRef {
+export interface ResourceResponsePart extends ContentRef {
     /** Discriminant */
     kind: ResponsePartKind.ContentRef;
 }
@@ -734,7 +845,56 @@ export interface ReasoningResponsePart {
 /**
  * @category Response Parts
  */
-export type ResponsePart = MarkdownResponsePart | ResourceReponsePart | ToolCallResponsePart | ReasoningResponsePart | SystemNotificationResponsePart;
+export type ResponsePart = MarkdownResponsePart | ResourceResponsePart | ToolCallResponsePart | ReasoningResponsePart | SystemNotificationResponsePart | InputRequestResponsePart | ErrorResponsePart;
+/**
+ * A live or resolved input request (elicitation) in the turn response stream.
+ *
+ * The server inserts the part with `chat/inputRequested`. While
+ * {@link response} is absent, clients can update answer drafts with
+ * `chat/inputAnswerChanged` and submit a response with `chat/inputCompleted`.
+ * Completion updates this part in place so its stream position is stable and
+ * the full interaction remains durable and backfillable via `fetchTurns`.
+ *
+ * If the turn ends without a submitted response, the unresolved part remains
+ * in the completed turn transcript with {@link response} absent.
+ *
+ * @category Response Parts
+ */
+export interface InputRequestResponsePart {
+    /** Discriminant */
+    kind: ResponsePartKind.InputRequest;
+    /**
+     * The request, carrying its `id`, `message`, `url`, `questions`, and current
+     * draft or submitted `answers`.
+     */
+    request: ChatInputRequest;
+    /**
+     * How the request was resolved. Absent until a client submits `accept`,
+     * `decline`, or `cancel` with `chat/inputCompleted`.
+     */
+    response?: ChatInputResponseKind;
+}
+/**
+ * An error encountered while processing a turn.
+ *
+ * This is the detailed source of truth for the error. {@link Turn.state}
+ * remains {@link TurnState.Error} while the turn is stopped at this error so
+ * clients can detect the terminal state without inspecting response parts.
+ *
+ * When {@link resumable} is `true`, a client may dispatch `chat/turnResume`
+ * while this is the latest turn and its state is {@link TurnState.Error}.
+ * Clients decide whether and how to present that affordance.
+ *
+ * @category Response Parts
+ */
+export interface ErrorResponsePart {
+    /** Discriminant */
+    kind: ResponsePartKind.Error;
+    /** Error details. */
+    error: ErrorInfo;
+    /** Whether the host can resume the turn from this error. Only `true` enables resume. */
+    resumable?: boolean;
+}
 /**
  * A system notification surfaced as part of the response stream.
  *
@@ -750,16 +910,33 @@ export interface SystemNotificationResponsePart {
     kind: ResponsePartKind.SystemNotification;
     /** The text of the system notification */
     content: StringOrMarkdown;
+    /**
+     * Additional provider-specific metadata for this notification.
+     *
+     * A host MAY attach a machine-readable descriptor of what triggered the
+     * notification so clients can categorize, icon, group, filter, or localize
+     * it without parsing `content`. Clients MAY look for well-known keys here to
+     * provide enhanced UI, and MUST render coherently from `content` alone when
+     * `_meta` is absent or unrecognized.
+     */
+    _meta?: Record<string, unknown>;
 }
 /**
  * Status of a tool call in the lifecycle state machine.
  *
  * @category Tool Call Types
+ * @nonexhaustive
  */
 export declare enum ToolCallStatus {
     Streaming = "streaming",
     PendingConfirmation = "pending-confirmation",
     Running = "running",
+    /**
+     * Running paused because the MCP server backing this call needs
+     * authentication (typically step-up auth for insufficient scope,
+     * surfacing mid-execution). See {@link ToolCallAuthRequiredState}.
+     */
+    AuthRequired = "auth-required",
     PendingResultConfirmation = "pending-result-confirmation",
     Completed = "completed",
     Cancelled = "cancelled"
@@ -772,16 +949,63 @@ export declare enum ToolCallStatus {
  * - `Setting` — Approved by a persistent user setting
  *
  * @category Tool Call Types
+ * @nonexhaustive
  */
 export declare enum ToolCallConfirmationReason {
     NotNeeded = "not-needed",
     UserAction = "user-action",
     Setting = "setting"
 }
+/**
+ * Identifies a model judge as the source of a confirmation requirement.
+ *
+ * @category Tool Call Types
+ * @nonexhaustive
+ */
+export declare enum ToolCallRiskAssessmentKind {
+    Judge = "judge"
+}
+/**
+ * Lifecycle status of an asynchronous model-judge confirmation decision.
+ *
+ * @category Tool Call Types
+ * @nonexhaustive
+ */
+export declare enum ToolCallRiskAssessmentStatus {
+    Loading = "loading",
+    Complete = "complete"
+}
+interface ToolCallRiskAssessmentBase {
+    kind: ToolCallRiskAssessmentKind;
+}
+/**
+ * The model judge is still evaluating the tool call.
+ *
+ * @category Tool Call Types
+ */
+export interface ToolCallRiskAssessmentLoadingState extends ToolCallRiskAssessmentBase {
+    status: ToolCallRiskAssessmentStatus.Loading;
+}
+/**
+ * The model judge has completed its evaluation.
+ *
+ * @category Tool Call Types
+ */
+export interface ToolCallRiskAssessmentCompleteState extends ToolCallRiskAssessmentBase {
+    status: ToolCallRiskAssessmentStatus.Complete;
+    reason: StringOrMarkdown;
+    /**
+     * The judge's normalized safety score, where `0` is unsafe and `1` is safe.
+     * @format float
+     */
+    safety: number;
+}
+export type ToolCallRiskAssessment = ToolCallRiskAssessmentLoadingState | ToolCallRiskAssessmentCompleteState;
 /**
  * Why a tool call was cancelled.
  *
  * @category Tool Call Types
+ * @exhaustive
  */
 export declare enum ToolCallCancellationReason {
     Denied = "denied",
@@ -792,6 +1016,7 @@ export declare enum ToolCallCancellationReason {
  * Whether a confirmation option represents an approval or denial action.
  *
  * @category Tool Call Types
+ * @nonexhaustive
  */
 export declare enum ConfirmationOptionKind {
     Approve = "approve",
@@ -820,6 +1045,12 @@ export interface ConfirmationOption {
      */
     group?: number;
 }
+/**
+ * Identifies the source of a tool call's implementation.
+ *
+ * @category Tool Call Types
+ * @nonexhaustive
+ */
 export declare enum ToolCallContributorKind {
     Client = "client",
     MCP = "mcp"
@@ -883,9 +1114,22 @@ interface ToolCallBase {
 interface ToolCallParameterFields {
     /** Message describing what the tool will do */
     invocationMessage: StringOrMarkdown;
-    /** Raw tool input */
-    toolInput?: string;
+    /**
+     * Final tool input.
+     *
+     * Referenced input is mutable until the tool call leaves
+     * `pending-confirmation`. When the client confirms with `editedToolInput`,
+     * the host MUST replace the resource contents before echoing the accepted
+     * confirmation action. Clients MUST NOT cache tool input across confirmation.
+     */
+    toolInput?: ToolInput;
 }
+/**
+ * Tool input represented inline or by reference.
+ *
+ * @category Tool Call Types
+ */
+export type ToolInput = string | ContentRef;
 /**
  * Tool execution result details, available after execution completes.
  *
@@ -921,7 +1165,7 @@ export interface ToolCallResult {
  */
 export interface ToolCallStreamingState extends ToolCallBase {
     status: ToolCallStatus.Streaming;
-    /** Partial parameters accumulated so far */
+    /** Partial parameters accumulated from tool-call deltas. */
     partialInput?: string;
     /** Progress message shown while parameters are streaming */
     invocationMessage?: StringOrMarkdown;
@@ -936,6 +1180,8 @@ export interface ToolCallPendingConfirmationState extends ToolCallBase, ToolCall
     status: ToolCallStatus.PendingConfirmation;
     /** 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[];
@@ -951,16 +1197,29 @@ export interface ToolCallPendingConfirmationState extends ToolCallBase, ToolCall
     options?: ConfirmationOption[];
 }
 /**
- * Tool is actively executing.
+ * Fields present on every tool call state that exists **after** confirmation
+ * has been resolved: {@link ToolCallRunningState}, {@link ToolCallAuthRequiredState},
+ * {@link ToolCallPendingResultConfirmationState}, and {@link ToolCallCompletedState}.
+ * `ToolCallPendingConfirmationState` (not yet confirmed) and
+ * `ToolCallCancelledState` (the denial path — never ran) don't satisfy this
+ * invariant, so they keep their own `selectedOption` field independently
+ * rather than extending this one.
  *
  * @category Tool Call Types
  */
-export interface ToolCallRunningState extends ToolCallBase, ToolCallParameterFields {
-    status: ToolCallStatus.Running;
+interface ToolCallPostConfirmationFields {
     /** How the tool was confirmed for execution */
     confirmed: ToolCallConfirmationReason;
     /** The confirmation option the user selected, if confirmation options were provided */
     selectedOption?: ConfirmationOption;
+}
+/**
+ * Tool is actively executing.
+ *
+ * @category Tool Call Types
+ */
+export interface ToolCallRunningState extends ToolCallBase, ToolCallParameterFields, ToolCallPostConfirmationFields {
+    status: ToolCallStatus.Running;
     /**
      * Partial content produced while the tool is still executing.
      *
@@ -969,29 +1228,61 @@ export interface ToolCallRunningState extends ToolCallBase, ToolCallParameterFie
      */
     content?: ToolResultContent[];
 }
+/**
+ * A running tool call is paused because the MCP server backing it needs
+ * authentication — most commonly {@link McpAuthRequirement.reason |
+ * `insufficientScope`} step-up auth triggered by the `tools/call` request
+ * itself. Only ever reached from {@link ToolCallRunningState}, and normally
+ * returns there once authenticated: `running` → `auth-required` → `running`
+ * → …. A client MAY instead cancel the invocation without authenticating by
+ * dispatching a `chat/toolCallComplete` with a **failed** result, always
+ * moving straight to {@link ToolCallCompletedState} —
+ * `requiresResultConfirmation` is ignored on this path, so it can never
+ * enter {@link ToolCallPendingResultConfirmationState}. A **successful**
+ * result dispatched from this state is invalid and MUST be rejected/ignored
+ * as a no-op by the reducer, since execution never resumed after the
+ * challenge.
+ *
+ * This is the tool-call-level counterpart to
+ * {@link McpServerAuthRequiredState} — that state means the MCP *server*
+ * cannot serve any request; this one means *this specific invocation* is
+ * waiting on the same kind of challenge. The two are dispatched
+ * independently and MAY be true at the same time, or not: an
+ * `insufficientScope` challenge triggered by a single tool call, for
+ * example, need not block the whole server.
+ *
+ * Because the challenge is always resolved by pushing a token via the
+ * existing `authenticate` command, this state can only originate from a
+ * tool call {@link ToolCallContributorKind.MCP | contributed by an MCP
+ * server} — `contributor` is narrowed accordingly (unlike the optional,
+ * multi-kind `contributor` on other tool call states).
+ *
+ * @category Tool Call Types
+ */
+export interface ToolCallAuthRequiredState extends ToolCallBase, ToolCallParameterFields, ToolCallPostConfirmationFields {
+    status: ToolCallStatus.AuthRequired;
+    /** The MCP server that contributed this tool call — always MCP, never a client tool. */
+    contributor: ToolCallMcpContributor;
+    /** The authentication challenge blocking this invocation. */
+    auth: McpAuthRequirement;
+    /** Partial content produced before the call paused for authentication. */
+    content?: ToolResultContent[];
+}
 /**
  * Tool finished executing, waiting for client to approve the result.
  *
  * @category Tool Call Types
  */
-export interface ToolCallPendingResultConfirmationState extends ToolCallBase, ToolCallParameterFields, ToolCallResult {
+export interface ToolCallPendingResultConfirmationState extends ToolCallBase, ToolCallParameterFields, ToolCallResult, ToolCallPostConfirmationFields {
     status: ToolCallStatus.PendingResultConfirmation;
-    /** How the tool was confirmed for execution */
-    confirmed: ToolCallConfirmationReason;
-    /** The confirmation option the user selected, if confirmation options were provided */
-    selectedOption?: ConfirmationOption;
 }
 /**
  * Tool completed successfully or with an error.
  *
  * @category Tool Call Types
  */
-export interface ToolCallCompletedState extends ToolCallBase, ToolCallParameterFields, ToolCallResult {
+export interface ToolCallCompletedState extends ToolCallBase, ToolCallParameterFields, ToolCallResult, ToolCallPostConfirmationFields {
     status: ToolCallStatus.Completed;
-    /** How the tool was confirmed for execution */
-    confirmed: ToolCallConfirmationReason;
-    /** The confirmation option the user selected, if confirmation options were provided */
-    selectedOption?: ConfirmationOption;
 }
 /**
  * Tool call was cancelled before execution.
@@ -1017,13 +1308,19 @@ export interface ToolCallCancelledState extends ToolCallBase, ToolCallParameterF
  *
  * @category Tool Call Types
  */
-export type ToolCallState = ToolCallStreamingState | ToolCallPendingConfirmationState | ToolCallRunningState | ToolCallPendingResultConfirmationState | ToolCallCompletedState | ToolCallCancelledState;
+export type ToolCallState = ToolCallStreamingState | ToolCallPendingConfirmationState | ToolCallRunningState | ToolCallAuthRequiredState | ToolCallPendingResultConfirmationState | ToolCallCompletedState | ToolCallCancelledState;
 /**
  * The two tool-call states that block on a client confirmation: parameter
  * confirmation before execution ({@link ToolCallPendingConfirmationState}) and
  * result confirmation after execution
  * ({@link ToolCallPendingResultConfirmationState}).
  *
+ * {@link ToolCallAuthRequiredState} is intentionally **not** part of this
+ * union: it doesn't block on a `chat/toolCallConfirmed`-style client
+ * decision, it blocks on the client completing an OAuth flow and calling
+ * `authenticate`. See {@link SessionToolAuthenticationRequest} for its
+ * session-level surfacing.
+ *
  * Surfaced at the session level by {@link SessionToolConfirmationRequest}.
  *
  * @category Tool Call Types
@@ -1033,6 +1330,7 @@ export type ToolCallConfirmationState = ToolCallPendingConfirmationState | ToolC
  * Discriminant for tool result content types.
  *
  * @category Tool Result Content
+ * @nonexhaustive
  */
 export declare enum ToolResultContentType {
     Text = "text",
@@ -1040,7 +1338,6 @@ export declare enum ToolResultContentType {
     Resource = "resource",
     FileEdit = "fileEdit",
     Terminal = "terminal",
-    ShellExit = "shell_exit",
     Subagent = "subagent"
 }
 /**
@@ -1093,6 +1390,11 @@ export interface ToolResultFileEditContent extends FileEdit {
  * Clients can subscribe to the terminal's URI to stream its output in real
  * time, providing live feedback while a tool is executing.
  *
+ * When the command exits, {@link result} is filled in on the completed
+ * result, retaining the outcome for clients that did not subscribe. This
+ * records the command's exit, not the terminal's — the terminal may keep
+ * running afterwards.
+ *
  * @category Tool Result Content
  */
 export interface ToolResultTerminalContent {
@@ -1101,24 +1403,33 @@ export interface ToolResultTerminalContent {
     resource: URI;
     /** Display title for the terminal content */
     title: string;
+    /**
+     * Whether this terminal-style resource is backed by a pseudoterminal.
+     * When `false`, output is plain text and clients do not need to parse
+     * VT sequences.
+     */
+    isPty?: boolean;
+    /** Outcome of the command, present once it has exited. */
+    result?: TerminalCommandResult;
 }
 /**
- * Shell command exit metadata emitted by the Copilot SDK shell tool.
+ * Outcome of a command run in a terminal-style tool, filled in on
+ * {@link ToolResultTerminalContent.result} once the command exits.
  *
  * @category Tool Result Content
  */
-export interface ToolResultShellExitContent {
-    type: ToolResultContentType.ShellExit;
-    /** Shell id, as assigned by Copilot runtime */
-    shellId: string;
-    /** Exit code from the completed shell command */
-    exitCode: number;
-    /** Working directory where the shell command was executed */
-    cwd?: string;
-    /** Output preview associated with the shell command, if available */
-    outputPreview?: string;
-    /** Whether outputPreview is known to be incomplete or truncated */
-    outputTruncated?: boolean;
+export interface TerminalCommandResult {
+    /** Exit code from the completed command, if reported by the runtime */
+    exitCode?: number;
+    /**
+     * Preview of the command's output, for clients that are not subscribed
+     * to the terminal or that arrive after it is disposed. When `isPty` is
+     * `true` the preview may contain VT sequences; when `false` it is plain
+     * text.
+     */
+    preview?: string;
+    /** Whether `preview` is known to be incomplete or truncated */
+    truncated?: boolean;
 }
 /**
  * A reference, embedded in a tool result, to a worker chat spawned by the tool
@@ -1147,11 +1458,11 @@ export interface ToolResultSubagentContent {
  * Mirrors the content blocks in MCP `CallToolResult.content`, plus
  * `ToolResultResourceContent` for lazy-loading large results,
  * `ToolResultFileEditContent` for file edit diffs,
- * `ToolResultTerminalContent` for live terminal output,
- * `ToolResultShellExitContent` for shell command exit metadata, and
+ * `ToolResultTerminalContent` for live terminal output and
+ * command completion metadata, and
  * `ToolResultSubagentContent` for tool-spawned worker chats (AHP extensions).
  *
  * @category Tool Result Content
  */
-export type ToolResultContent = ToolResultTextContent | ToolResultEmbeddedResourceContent | ToolResultResourceContent | ToolResultFileEditContent | ToolResultTerminalContent | ToolResultShellExitContent | ToolResultSubagentContent;
+export type ToolResultContent = ToolResultTextContent | ToolResultEmbeddedResourceContent | ToolResultResourceContent | ToolResultFileEditContent | ToolResultTerminalContent | ToolResultSubagentContent;
 export {};