@codingame/monaco-vscode-api 36.2.7 → 37.1.0

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

@@ -1,16 +1,17 @@
 import type { Changeset } from "../channels-changeset/state.js";
 import type { AnnotationsSummary } from "../channels-annotations/state.js";
-import type { ChatSummary, ChatInputRequest, ToolCallConfirmationState, ToolCallState } from "../channels-chat/state.js";
+import type { ChatSummary, ChatInputRequest, ToolCallConfirmationState, ToolCallRunningState, ToolCallAuthRequiredState } from "../channels-chat/state.js";
 import type { ConfigPropertySchema, ErrorInfo, Icon, ProtectedResourceMetadata, TextRange, URI } from "../common/state.js";
 /**
  * Session initialization state.
  *
  * @category Session State
+ * @nonexhaustive
  */
 export declare enum SessionLifecycle {
     Creating = "creating",
     Ready = "ready",
-    CreationFailed = "creationFailed"
+    Failed = "failed"
 }
 /**
  * Bitset of summary-level session status flags.
@@ -20,6 +21,7 @@ export declare enum SessionLifecycle {
  * and turns that are paused waiting for input.
  *
  * @category Session State
+ * @nonexhaustive
  */
 export declare enum SessionStatus {
     /** Session is idle — no turn is active. */
@@ -35,6 +37,38 @@ export declare enum SessionStatus {
     /** The session has been archived by the client. */
     IsArchived = 64
 }
+/**
+ * Discriminant describing the durable provenance of a session.
+ *
+ * @category Session State
+ * @nonexhaustive
+ */
+export declare enum SessionOriginKind {
+    /** The session was created as part of an automation run. */
+    Automation = "automation"
+}
+/**
+ * Provenance recorded on a session created for an automation run.
+ *
+ * The links let clients navigate from an ordinary session to the task-level
+ * run and its durable definition. The session channel remains authoritative
+ * for this session's transcript, tools, confirmations, and changes.
+ *
+ * @category Session State
+ */
+export interface AutomationSessionOrigin {
+    kind: SessionOriginKind.Automation;
+    /** Owning {@link AutomationEntry.resource}. */
+    automation: URI;
+    /** Owning {@link AutomationRunState.resource}. */
+    run: URI;
+}
+/**
+ * Durable provenance for sessions created by a higher-level AHP workflow.
+ *
+ * @category Session State
+ */
+export type SessionOrigin = AutomationSessionOrigin;
 /**
  * Metadata shared between the full {@link SessionState} (delivered when a
  * client subscribes to a session's URI) and the lightweight
@@ -57,15 +91,23 @@ export interface SessionMetadata {
     status: SessionStatus;
     /** Human-readable description of what the session is currently doing */
     activity?: string;
+    /** Durable {@link AutomationSessionOrigin}, when an automation run created this session. */
+    origin?: SessionOrigin;
     /** Server-owned project for this session */
     project?: ProjectInfo;
     /**
-     * The default working directory URI for this session. Individual chats
-     * MAY override via {@link ChatSummary.workingDirectory | their own
-     * `workingDirectory`}; this field acts as the fallback for any chat that
-     * does not.
+     * The working directories the session's agent has tool access to, as
+     * maintained by working-directory actions. Directories are equal peers except
+     * when the agent advertises
+     * {@link MultipleWorkingDirectoriesCapability.immutablePrimary} without
+     * {@link MultipleWorkingDirectoriesCapability.primaryReplacement} (the first
+     * entry is then a fixed process root), or advertises `primaryReplacement`
+     * (the first entry is a protected, replaceable primary slot). Individual chats
+     * MAY restrict to a subset via
+     * {@link ChatSummary.workingDirectories | their own `workingDirectories`}; a
+     * chat that sets none operates against this full set.
      */
-    workingDirectory?: URI;
+    workingDirectories?: URI[];
     /**
      * Lightweight summary of this session's inline annotations channel
      * (`ahp-session:/<uuid>/annotations`). Surfaced so badge UI can render
@@ -153,9 +195,12 @@ export interface SessionState extends SessionMetadata {
      * Each entry is self-sufficient: it carries the owning chat's URI plus every
      * identifier the client needs to respond. A client answers by dispatching the
      * ordinary `chat/*` action to that chat's channel — see
-     * {@link SessionInputRequest} for the per-variant response path. A present,
-     * non-empty list implies {@link SessionStatus.InputNeeded} on
-     * {@link SessionSummary.status}.
+     * {@link SessionInputRequest} for the per-variant response path. A list
+     * holding any entry other than
+     * {@link SessionInputRequestKind.ToolClientExecution} implies
+     * {@link SessionStatus.InputNeeded} on {@link SessionSummary.status};
+     * client-execution entries are work delegated to a client rather than a
+     * prompt, so they leave the session's activity unchanged.
      *
      * Host-managed: the host upserts entries with `session/inputNeededSet` as
      * chats raise requests and removes them with `session/inputNeededRemoved`
@@ -167,7 +212,7 @@ export interface SessionState extends SessionMetadata {
      *
      * Clients MAY look for well-known keys here to provide enhanced UI.
      * For example, a `git` key may provide extra git metadata about the session's
-     * workingDirectory.
+     * working directories.
      */
     _meta?: Record<string, unknown>;
 }
@@ -205,14 +250,17 @@ export interface SessionActiveClient {
  * a `*Kind`.
  *
  * @category Session Input Types
+ * @nonexhaustive
  */
 export declare enum SessionInputRequestKind {
-    /** A user-facing elicitation mirrored from a chat's `inputRequests`. */
+    /** A user-facing elicitation mirrored from an unresolved chat response part. */
     ChatInput = "chatInput",
     /** A tool call awaiting parameter- or result-confirmation. */
     ToolConfirmation = "toolConfirmation",
     /** A running tool the session wants an active client to execute. */
-    ToolClientExecution = "toolClientExecution"
+    ToolClientExecution = "toolClientExecution",
+    /** A tool call blocked on MCP authentication mid-execution. */
+    ToolAuthentication = "toolAuthentication"
 }
 /**
  * Fields common to every {@link SessionInputRequest} variant.
@@ -236,8 +284,8 @@ interface SessionInputRequestBase {
     chat: URI;
 }
 /**
- * A user-input elicitation surfaced at the session level, mirroring one entry
- * of the owning chat's {@link ChatState.inputRequests}.
+ * A user-input elicitation surfaced at the session level, mirroring the request
+ * from an unresolved {@link InputRequestResponsePart} in the owning chat.
  *
  * Respond by dispatching `chat/inputCompleted` (or syncing drafts with
  * `chat/inputAnswerChanged`) to {@link SessionInputRequestBase.chat | `chat`},
@@ -283,6 +331,11 @@ export interface SessionToolConfirmationRequest extends SessionInputRequestBase
  * `chat/toolCallContentChanged`) to {@link SessionInputRequestBase.chat |
  * `chat`}, keyed by `turnId` and `toolCall.toolCallId`.
  *
+ * Unlike the other variants this does **not** raise
+ * {@link SessionStatus.InputNeeded}: the call has already cleared its
+ * confirmation gate and is merely executing elsewhere, so the session stays
+ * {@link SessionStatus.InProgress} while it runs.
+ *
  * @category Session Input Types
  */
 export interface SessionToolClientExecutionRequest extends SessionInputRequestBase {
@@ -296,10 +349,33 @@ export interface SessionToolClientExecutionRequest extends SessionInputRequestBa
     clientId: string;
     /**
      * The running tool call the session wants the owning client to execute. The
-     * host only ever populates this with a {@link ToolCallRunningState} (i.e. a
-     * {@link ToolCallState} in `running` status).
+     * host only ever populates this with a {@link ToolCallRunningState}.
      */
-    toolCall: ToolCallState;
+    toolCall: ToolCallRunningState;
+}
+/**
+ * A tool call blocked on MCP authentication mid-execution, surfaced at the
+ * session level.
+ *
+ * The {@link toolCall} is always a {@link ToolCallAuthRequiredState} (a
+ * {@link ToolCallState} in `auth-required` status). Unlike
+ * {@link SessionToolConfirmationRequest}, this is **not** answered by
+ * dispatching a `chat/*` action directly: the client obtains a token for
+ * {@link ToolCallAuthRequiredState.auth | `toolCall.auth`}`.resource` and
+ * pushes it via the existing `authenticate` command (see
+ * {@link /specification/authentication | Authentication}). The host resumes
+ * the tool call and dispatches `chat/toolCallAuthResolved` once the token is
+ * accepted, at which point it also removes this entry with
+ * `session/inputNeededRemoved`.
+ *
+ * @category Session Input Types
+ */
+export interface SessionToolAuthenticationRequest extends SessionInputRequestBase {
+    kind: SessionInputRequestKind.ToolAuthentication;
+    /** The turn the tool call belongs to. */
+    turnId: string;
+    /** The tool call awaiting authentication. */
+    toolCall: ToolCallAuthRequiredState;
 }
 /**
  * One outstanding piece of input a session is blocked on, aggregated across all
@@ -310,12 +386,13 @@ export interface SessionToolClientExecutionRequest extends SessionInputRequestBa
  * to construct the response, so a client can answer by dispatching the ordinary
  * `chat/*` action (`chat/inputCompleted`, `chat/toolCallConfirmed`,
  * `chat/toolCallComplete`, …) to that chat's channel **without having subscribed
- * to the chat**. The host removes the entry with `session/inputNeededRemoved`
- * once the underlying request resolves.
+ * to the chat** — except {@link SessionToolAuthenticationRequest}, which is
+ * resolved via the `authenticate` command instead. The host removes the entry
+ * with `session/inputNeededRemoved` once the underlying request resolves.
  *
  * @category Session Input Types
  */
-export type SessionInputRequest = SessionChatInputRequest | SessionToolConfirmationRequest | SessionToolClientExecutionRequest;
+export type SessionInputRequest = SessionChatInputRequest | SessionToolConfirmationRequest | SessionToolClientExecutionRequest | SessionToolAuthenticationRequest;
 /**
  * Server-owned project metadata for a session.
  *
@@ -349,9 +426,9 @@ export interface ProjectInfo {
  *   chat currently driving the promoted status bits when a non-default chat
  *   wins (e.g. the chat that raised `InputNeeded`).
  * - `modifiedAt`: the max of all chats' `modifiedAt`.
- * - `workingDirectory`: the session-level **default**. Individual chats MAY
- *   override via {@link ChatSummary.workingDirectory}; aggregating these up
- *   is meaningless and SHOULD NOT be attempted.
+ * - `workingDirectories`: the session-level set. Individual chats MAY restrict
+ *   to a subset via {@link ChatSummary.workingDirectories}; aggregating these
+ *   up is meaningless and SHOULD NOT be attempted.
  * - `changes`: optional roll-up across all chats. Producers MAY sum the
  *   per-chat changeset stats or report the most expensive chat's stats —
  *   whichever is cheaper for the host to compute.
@@ -536,6 +613,7 @@ export interface ToolAnnotations {
  * a container.
  *
  * @category Customization Types
+ * @nonexhaustive
  */
 export declare enum CustomizationType {
     Plugin = "plugin",
@@ -547,6 +625,29 @@ export declare enum CustomizationType {
     Hook = "hook",
     McpServer = "mcpServer"
 }
+/**
+ * Scope at which customization enablement is decided.
+ *
+ * @category Customization Types
+ * @nonexhaustive
+ */
+export declare enum CustomizationEnablementKind {
+    Global = "global",
+    Workspace = "workspace",
+    Session = "session"
+}
+/** A single explicit enablement decision. */
+export type CustomizationEnablement = {
+    kind: CustomizationEnablementKind.Global;
+    enabled: boolean;
+} | {
+    kind: CustomizationEnablementKind.Workspace;
+    uri: URI;
+    enabled: boolean;
+} | {
+    kind: CustomizationEnablementKind.Session;
+    enabled: boolean;
+};
 /**
  * Customization types that appear as children of a
  * {@link PluginCustomization} or {@link DirectoryCustomization}.
@@ -587,11 +688,20 @@ interface CustomizationBase {
      * Absent when the customization covers the whole resource.
      */
     range?: TextRange;
+    /**
+     * Additional provider-specific metadata for this customization.
+     *
+     * Mirrors the MCP `_meta` convention. Optional and opaque to the
+     * protocol; producers and consumers agree on its contents
+     * out-of-band.
+     */
+    _meta?: Record<string, unknown>;
 }
 /**
  * Discriminant values for {@link CustomizationLoadState}.
  *
  * @category Customization Types
+ * @exhaustive
  */
 export declare enum CustomizationLoadStatus {
     Loading = "loading",
@@ -648,8 +758,6 @@ export type CustomizationLoadState = CustomizationLoadingState | CustomizationLo
  * @category Customization Types
  */
 interface ContainerCustomizationBase extends CustomizationBase {
-    /** Whether this container is currently enabled. */
-    enabled: boolean;
     /**
      * `clientId` of the client that contributed this container. Absent for
      * server-originated entries.
@@ -676,6 +784,17 @@ interface ContainerCustomizationBase extends CustomizationBase {
  */
 export interface PluginCustomization extends ContainerCustomizationBase {
     type: CustomizationType.Plugin;
+    /** Explicit enablement decisions. See {@link McpServerCustomization.enablement}. */
+    enablement?: CustomizationEnablement[];
+    /**
+     * Version of the plugin, sourced from the
+     * [Open Plugins](https://open-plugins.com/) manifest's optional
+     * `version` field (semver, e.g. `"1.2.0"`). Absent when the manifest
+     * declares no version — the field is optional there — or the source
+     * has no version concept. Provenance / display only: the host neither
+     * parses nor enforces it.
+     */
+    version?: string;
 }
 /**
  * A {@link PluginCustomization} as published by a client. Extends the
@@ -693,6 +812,17 @@ export interface PluginCustomization extends ContainerCustomizationBase {
 export interface ClientPluginCustomization extends PluginCustomization {
     /** Opaque version token used by the host to detect changes. */
     nonce?: string;
+    /**
+     * Explicit enablement decisions for children this plugin contributes,
+     * keyed by child name (for MCP servers, the server name as it appears in
+     * the bundled `.mcp.json`).
+     *
+     * Bundled children are discovered by the host rather than published by the
+     * client, so the client cannot attach `enablement` to them directly. This
+     * carries the client's global decision for each one; the host applies it
+     * under the child's durable key.
+     */
+    childEnablement?: Record<string, CustomizationEnablement[]>;
 }
 /**
  * A directory the host watches for this session.
@@ -709,11 +839,41 @@ export interface ClientPluginCustomization extends PluginCustomization {
  */
 export interface DirectoryCustomization extends ContainerCustomizationBase {
     type: CustomizationType.Directory;
+    /** Whether this container is currently enabled. */
+    enabled: boolean;
     /** Which child customization type this directory holds. */
     contents: ChildCustomizationType;
     /** Whether clients may write into this directory. */
     writable: boolean;
 }
+/**
+ * Fields shared by the leaf child customizations that live inside a
+ * container — {@link AgentCustomization}, {@link SkillCustomization},
+ * {@link PromptCustomization}, {@link RuleCustomization}, and
+ * {@link HookCustomization}.
+ *
+ * {@link McpServerCustomization} is also a child but does not extend this
+ * base because it can appear as a top-level customization too.
+ *
+ * @category Customization Types
+ */
+interface ChildCustomizationBase extends CustomizationBase {
+    /**
+     * Whether this child is individually enabled. Absent means enabled, so a
+     * producer only needs to set it to surface a child that exists but is
+     * turned off on its own.
+     *
+     * This flag is independent of the parent container's: the **effective**
+     * enabled state of a plugin child is the plugin's derived enabled value and
+     * `(child.enabled ?? true)`, so a disabled plugin disables every child
+     * regardless of each child's own flag. A directory child instead uses the
+     * directory's `enabled` value and its own flag.
+     *
+     * A child is turned on or off by id with
+     * {@link SessionCustomizationToggledAction | `session/customizationToggled`}.
+     */
+    enabled?: boolean;
+}
 /**
  * A custom agent contributed by a plugin or directory.
  *
@@ -723,7 +883,7 @@ export interface DirectoryCustomization extends ContainerCustomizationBase {
  *
  * @category Customization Types
  */
-export interface AgentCustomization extends CustomizationBase {
+export interface AgentCustomization extends ChildCustomizationBase {
     type: CustomizationType.Agent;
     /**
      * Short description of what the agent specializes in and when to
@@ -747,11 +907,17 @@ export interface AgentCustomization extends CustomizationBase {
      */
     tools?: string[];
     /**
-     * Additional provider-specific metadata for this custom agent.
-     *
-     * Mirrors the MCP `_meta` convention.
+     * When `true`, the agent will not auto-delegate to this custom agent
+     * as a sub-agent; it can only be selected by the user. Absent or
+     * `false` means the agent may delegate to it.
      */
-    _meta?: Record<string, unknown>;
+    disableModelInvocation?: boolean;
+    /**
+     * When `true`, the user cannot select this custom agent (for example,
+     * in a picker); it remains available for the agent to auto-delegate
+     * to. Absent or `false` means the user may select it.
+     */
+    disableUserInvocation?: boolean;
 }
 /**
  * A skill contributed by a plugin or directory.
@@ -763,7 +929,7 @@ export interface AgentCustomization extends CustomizationBase {
  *
  * @category Customization Types
  */
-export interface SkillCustomization extends CustomizationBase {
+export interface SkillCustomization extends ChildCustomizationBase {
     type: CustomizationType.Skill;
     /**
      * Short description used for help text and auto-invocation matching.
@@ -776,13 +942,19 @@ export interface SkillCustomization extends CustomizationBase {
      * `disable-model-invocation` flag.
      */
     disableModelInvocation?: boolean;
+    /**
+     * When `true`, the user cannot directly invoke this skill (for example,
+     * as a slash command); it remains available for the agent to
+     * auto-invoke. Absent or `false` means the user may invoke it.
+     */
+    disableUserInvocation?: boolean;
 }
 /**
  * A prompt contributed by a plugin or directory.
  *
  * @category Customization Types
  */
-export interface PromptCustomization extends CustomizationBase {
+export interface PromptCustomization extends ChildCustomizationBase {
     type: CustomizationType.Prompt;
     /** Short description of what the prompt does. */
     description?: string;
@@ -800,7 +972,7 @@ export interface PromptCustomization extends CustomizationBase {
  *
  * @category Customization Types
  */
-export interface RuleCustomization extends CustomizationBase {
+export interface RuleCustomization extends ChildCustomizationBase {
     type: CustomizationType.Rule;
     /**
      * Description of what the rule enforces.
@@ -823,7 +995,7 @@ export interface RuleCustomization extends CustomizationBase {
  *
  * @category Customization Types
  */
-export interface HookCustomization extends CustomizationBase {
+export interface HookCustomization extends ChildCustomizationBase {
     type: CustomizationType.Hook;
 }
 /**
@@ -841,9 +1013,23 @@ export interface HookCustomization extends CustomizationBase {
 export interface McpServerCustomization extends CustomizationBase {
     type: CustomizationType.McpServer;
     /**
-     * Whether this MCP server is currently enabled.
+     * Explicit enablement decisions for this customization, one entry per scope
+     * that has one. This is a wire contract: producers MUST publish entries
+     * sorted by descending specificity (Session, Workspace, then Global).
+     * The agent host emits at most one Workspace entry, for the session's primary
+     * working directory. Consumers MAY treat
+     * `enablement[0]` as the decisive decision and
+     * `enablement?.[0]?.enabled ?? true` as the effective enabled value. An
+     * absent or empty array means no explicit decision exists, so the
+     * customization is enabled by default.
+     *
+     * Flows in both directions. A client publishes this alongside a customization
+     * to assert its global decision, which is authoritative for the Global scope;
+     * a client always includes its global entry, even when enabled. The host
+     * publishes the fully resolved set across all scopes, and consumers derive
+     * the effective enabled value from that set.
      */
-    enabled: boolean;
+    enablement?: CustomizationEnablement[];
     /**
      * Current lifecycle state of the MCP server.
      */
@@ -970,6 +1156,7 @@ export type Customization = PluginCustomization | DirectoryCustomization | McpSe
  * Discriminant for the {@link McpServerState} union.
  *
  * @category MCP Server State
+ * @nonexhaustive
  */
 export declare enum McpServerStatus {
     /** Server has been registered but is not yet running. */
@@ -995,6 +1182,7 @@ export declare enum McpServerStatus {
  * [MCP authorization spec](https://modelcontextprotocol.io/specification/2025-11-25/basic/authorization.md).
  *
  * @category MCP Server State
+ * @nonexhaustive
  */
 export declare enum McpAuthRequiredReason {
     /** No token has been provided yet (HTTP 401, no prior token). */
@@ -1037,6 +1225,68 @@ export interface McpServerStartingState {
 export interface McpServerReadyState {
     kind: McpServerStatus.Ready;
 }
+/**
+ * A pre-registered OAuth client that clients use instead of dynamic client
+ * registration when resolving an MCP authentication challenge.
+ *
+ * @category MCP Server State
+ */
+export interface McpOAuthClient {
+    /** OAuth client identifier registered with the authorization server. */
+    clientId: string;
+    /**
+     * OAuth client secret for a confidential client. Absence means the client is
+     * public and uses a secretless flow such as authorization code with PKCE.
+     */
+    clientSecret?: string;
+}
+/**
+ * Reusable MCP authentication challenge — the RFC 9728 discovery info a
+ * client needs to obtain a token and push it via the `authenticate` command.
+ * Deliberately carries **no token**: this describes what is being asked for,
+ * never the bearer token itself.
+ *
+ * Shared by two independent state machines that describe the same OAuth
+ * challenge from different vantage points:
+ *
+ * - {@link McpServerAuthRequiredState} — the MCP server itself cannot serve
+ *   *any* request until the client authenticates.
+ * - {@link ToolCallAuthRequiredState} — a specific in-flight tool call is
+ *   paused pending authentication (typically
+ *   {@link McpAuthRequiredReason.InsufficientScope} step-up auth
+ *   mid-execution). The server state and the tool-call state remain
+ *   separate on purpose: the server saying "I need auth" and a tool
+ *   invocation saying "I am waiting on that auth" are different facts that
+ *   can be true independently.
+ *
+ * @category MCP Server State
+ */
+export interface McpAuthRequirement {
+    /** Why authentication is required. */
+    reason: McpAuthRequiredReason;
+    /**
+     * Pre-registered OAuth client to use for authorization. When present, clients
+     * MUST use these credentials instead of dynamic client registration.
+     */
+    oauthClient?: McpOAuthClient;
+    /**
+     * RFC 9728 Protected Resource Metadata. The `resource` field is the
+     * canonical MCP server URI per RFC 8707, used as the OAuth `resource`
+     * indicator. `authorization_servers` is REQUIRED by the MCP
+     * authorization spec.
+     */
+    resource: ProtectedResourceMetadata;
+    /**
+     * Scopes required for the current challenge, parsed from the
+     * `WWW-Authenticate: Bearer scope="…"` header (or `scopes_supported`
+     * fallback). Authoritative for the next authorization request — clients
+     * MUST NOT assume any subset/superset relationship to
+     * `resource.scopes_supported`.
+     */
+    requiredScopes?: string[];
+    /** Human-readable hint, typically from the OAuth `error_description`. */
+    description?: string;
+}
 /**
  * Server is reachable but cannot serve requests until the client
  * authenticates. Mirrors the discovery flow defined by
@@ -1062,27 +1312,8 @@ export interface McpServerReadyState {
  *
  * @category MCP Server State
  */
-export interface McpServerAuthRequiredState {
+export interface McpServerAuthRequiredState extends McpAuthRequirement {
     kind: McpServerStatus.AuthRequired;
-    /** Why authentication is required. */
-    reason: McpAuthRequiredReason;
-    /**
-     * RFC 9728 Protected Resource Metadata. The `resource` field is the
-     * canonical MCP server URI per RFC 8707, used as the OAuth `resource`
-     * indicator. `authorization_servers` is REQUIRED by the MCP
-     * authorization spec.
-     */
-    resource: ProtectedResourceMetadata;
-    /**
-     * Scopes required for the current challenge, parsed from the
-     * `WWW-Authenticate: Bearer scope="…"` header (or `scopes_supported`
-     * fallback). Authoritative for the next authorization request — clients
-     * MUST NOT assume any subset/superset relationship to
-     * `resource.scopes_supported`.
-     */
-    requiredScopes?: string[];
-    /** Human-readable hint, typically from the OAuth `error_description`. */
-    description?: string;
 }
 /**
  * Server failed to start, crashed, or otherwise transitioned to a

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

@@ -4,7 +4,7 @@ var SessionLifecycle;
 (function (SessionLifecycle) {
     SessionLifecycle["Creating"] = "creating";
     SessionLifecycle["Ready"] = "ready";
-    SessionLifecycle["CreationFailed"] = "creationFailed";
+    SessionLifecycle["Failed"] = "failed";
 })(SessionLifecycle || (SessionLifecycle = {}));
 var SessionStatus;
 (function (SessionStatus) {
@@ -15,11 +15,16 @@ var SessionStatus;
     SessionStatus[SessionStatus["IsRead"] = 32] = "IsRead";
     SessionStatus[SessionStatus["IsArchived"] = 64] = "IsArchived";
 })(SessionStatus || (SessionStatus = {}));
+var SessionOriginKind;
+(function (SessionOriginKind) {
+    SessionOriginKind["Automation"] = "automation";
+})(SessionOriginKind || (SessionOriginKind = {}));
 var SessionInputRequestKind;
 (function (SessionInputRequestKind) {
     SessionInputRequestKind["ChatInput"] = "chatInput";
     SessionInputRequestKind["ToolConfirmation"] = "toolConfirmation";
     SessionInputRequestKind["ToolClientExecution"] = "toolClientExecution";
+    SessionInputRequestKind["ToolAuthentication"] = "toolAuthentication";
 })(SessionInputRequestKind || (SessionInputRequestKind = {}));
 var CustomizationType;
 (function (CustomizationType) {
@@ -32,6 +37,12 @@ var CustomizationType;
     CustomizationType["Hook"] = "hook";
     CustomizationType["McpServer"] = "mcpServer";
 })(CustomizationType || (CustomizationType = {}));
+var CustomizationEnablementKind;
+(function (CustomizationEnablementKind) {
+    CustomizationEnablementKind["Global"] = "global";
+    CustomizationEnablementKind["Workspace"] = "workspace";
+    CustomizationEnablementKind["Session"] = "session";
+})(CustomizationEnablementKind || (CustomizationEnablementKind = {}));
 var CustomizationLoadStatus;
 (function (CustomizationLoadStatus) {
     CustomizationLoadStatus["Loading"] = "loading";
@@ -54,4 +65,4 @@ var McpAuthRequiredReason;
     McpAuthRequiredReason["InsufficientScope"] = "insufficientScope";
 })(McpAuthRequiredReason || (McpAuthRequiredReason = {}));
 
-export { CustomizationLoadStatus, CustomizationType, McpAuthRequiredReason, McpServerStatus, SessionInputRequestKind, SessionLifecycle, SessionStatus };
+export { CustomizationEnablementKind, CustomizationLoadStatus, CustomizationType, McpAuthRequiredReason, McpServerStatus, SessionInputRequestKind, SessionLifecycle, SessionOriginKind, SessionStatus };