@codingame/monaco-vscode-api 36.2.6 → 37.0.0

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

@@ -23,6 +23,97 @@ import type { TelemetryCapabilities } from "../channels-otlp/state.js";
 export interface BaseParams {
     /** Channel URI this command targets. */
     channel: URI;
+    /**
+     * Optional JSON-serializable metadata associated with this request.
+     * Receivers MUST ignore keys they do not understand.
+     */
+    _meta?: Record<string, unknown>;
+}
+/**
+ * Cursor-based pagination inputs, mixed into the params of any list command
+ * that can page a large result set (e.g. {@link ListSessionsParams |
+ * `listSessions`}). The paired output is {@link PaginatedResult}.
+ *
+ * Pagination is **opaque and cursor-based**, mirroring the shape `fetchTurns`
+ * already uses for chat history: the server owns the ordering and keyset, and
+ * the client walks pages by echoing the cursor from the previous
+ * {@link PaginatedResult.nextCursor} back on the next request.
+ *
+ * The contract every paginated command shares:
+ *
+ * - To fetch the first page, omit `cursor`. Supply `limit` to bound the page.
+ * - If the result carries a {@link PaginatedResult.nextCursor}, more entries
+ *   exist — pass it back as `cursor` to fetch the following page. A missing
+ *   `nextCursor` signals the end of the collection.
+ * - Cursors are **server-defined and opaque**: clients MUST NOT parse, modify,
+ *   or persist them across connections. An unrecognised cursor SHOULD be
+ *   rejected with an `InvalidParams` error.
+ * - Pagination is **fully additive**: a client that omits `limit`/`cursor` and
+ *   ignores `nextCursor` sees the pre-pagination behaviour (subject to any
+ *   server-imposed cap), and a server that does not paginate ignores the inputs
+ *   and returns everything in a single page.
+ *
+ * @category Commands
+ */
+export interface PaginatedParams {
+    /**
+     * Maximum number of entries to return in this page. The server SHOULD respect
+     * this bound but MAY return fewer entries and MAY impose its own upper cap.
+     * Omit to let the server choose the page size.
+     */
+    limit?: number;
+    /**
+     * Opaque pagination cursor from a previous {@link PaginatedResult.nextCursor}.
+     * Omit to fetch the first page. Cursors are server-defined and MUST be treated
+     * as opaque — do not parse, modify, or persist them across connections. An
+     * unrecognised cursor SHOULD be rejected with an `InvalidParams` error.
+     */
+    cursor?: string;
+}
+/**
+ * Cursor-based pagination output, extended by the result of any list command
+ * that can page a large result set (e.g. {@link ListSessionsResult |
+ * `listSessions`}). See {@link PaginatedParams} for the full pagination
+ * contract shared by every paginated command.
+ *
+ * @category Commands
+ */
+export interface PaginatedResult {
+    /**
+     * Opaque cursor for the next page. Present when more entries exist beyond the
+     * returned page; absent signals the end of the collection. Pass it back as
+     * {@link PaginatedParams.cursor} to fetch the following page.
+     */
+    nextCursor?: string;
+}
+/**
+ * Identifies a protocol implementation — the software (and build) on one end
+ * of the connection, as distinct from the {@link AgentInfo | agent persona} it
+ * hosts. Carried as {@link InitializeParams.clientInfo | `clientInfo`} on the
+ * client side and {@link InitializeResult.serverInfo | `serverInfo`} on the
+ * server side, mirroring LSP's `clientInfo`/`serverInfo` and MCP's
+ * `Implementation`.
+ *
+ * This is **informational only**: it exists for logging, telemetry, an
+ * about/status affordance, and — as a last resort — a known-issue workaround
+ * for a specific buggy build. It is **not** a feature-detection mechanism.
+ * Feature availability stays with the capability model
+ * ({@link ClientCapabilities} and the various `*.capabilities` declarations);
+ * implementations SHOULD NOT gate protocol behaviour on parsing
+ * {@link Implementation.version | `version`}.
+ *
+ * @category Commands
+ */
+export interface Implementation {
+    /** Implementation name, e.g. a product or package identifier. */
+    name: string;
+    /**
+     * Implementation version. A [SemVer](https://semver.org) string is
+     * recommended but not required.
+     */
+    version?: string;
+    /** Optional human-readable display name. */
+    title?: string;
 }
 /**
  * Establishes a new connection and negotiates the protocol version.
@@ -44,11 +135,20 @@ export interface InitializeParams extends BaseParams {
      *
      * The server selects one entry and returns it as `InitializeResult.protocolVersion`.
      * If the server cannot speak any of the offered versions, it MUST return
-     * error code `-32005` (`UnsupportedProtocolVersion`).
+     * error code `-32005` (`UnsupportedProtocolVersion`) with required
+     * `UnsupportedProtocolVersionErrorData` containing `supportedVersions`.
      */
     protocolVersions: string[];
     /** Unique client identifier */
     clientId: string;
+    /**
+     * Optional identity of the client implementation (name and version).
+     * Informational only — see {@link Implementation} for how it may and may not
+     * be used. Distinct from {@link InitializeParams.clientId | `clientId`},
+     * which is an opaque per-connection identifier used for reconnection, not a
+     * human-readable implementation name.
+     */
+    clientInfo?: Implementation;
     /** URIs to subscribe to during handshake */
     initialSubscriptions?: URI[];
     /**
@@ -98,7 +198,8 @@ export interface ClientCapabilities {
  * `protocolVersions` list. The client and server MUST use this version for
  * the rest of the connection. If the server cannot speak any of the offered
  * versions it MUST return error code `-32005` (`UnsupportedProtocolVersion`)
- * instead of a result.
+ * with required `UnsupportedProtocolVersionErrorData` containing
+ * `supportedVersions`, instead of a result.
  */
 export interface InitializeResult {
     /**
@@ -109,6 +210,23 @@ export interface InitializeResult {
     protocolVersion: string;
     /** Current server sequence number */
     serverSeq: number;
+    /**
+     * Optional identity of the server implementation (name and version).
+     * Informational only — see {@link Implementation} for how it may and may not
+     * be used. Whereas {@link InitializeResult.protocolVersion | `protocolVersion`}
+     * identifies the negotiated protocol, `serverInfo` identifies the host
+     * software behind it.
+     */
+    serverInfo?: Implementation;
+    /**
+     * Optional implementation-specific extension metadata advertised by the host.
+     *
+     * Hosts and clients MAY agree on namespaced keys for capabilities that are not
+     * part of the standardized protocol. Clients MUST ignore keys they do not
+     * understand. Capabilities needed for interoperable behavior SHOULD use typed
+     * fields on {@link InitializeResult} instead.
+     */
+    _meta?: Record<string, unknown>;
     /** Snapshots for each `initialSubscriptions` URI */
     snapshots: Snapshot[];
     /** Suggested default directory for remote filesystem browsing */
@@ -120,6 +238,13 @@ export interface InitializeResult {
      * `'@'` or `'/'`.
      */
     completionTriggerCharacters?: string[];
+    /**
+     * Prefix that the host recognizes at the start of a user {@link Message.text}
+     * as a shorthand for executing the remainder as a terminal command. Currently
+     * the standardized convention is `"!"`; absence means the host does not
+     * support command prefixes.
+     */
+    terminalCommandPrefix?: string;
     /**
      * OTLP telemetry channels the host emits, if any. Each populated field is
      * either a literal `ahp-otlp:` channel URI or an RFC 6570 URI template a
@@ -130,6 +255,82 @@ export interface InitializeResult {
      * @see {@link /specification/telemetry-channel | Telemetry Channel}
      */
     telemetry?: TelemetryCapabilities;
+    /**
+     * Host-owned automation support. Presence means clients may subscribe to
+     * `ahp-automations://` for {@link AutomationState}; absence means the
+     * host does not expose an automation catalogue or automation commands.
+     *
+     * @see {@link /guide/automations | Automations Guide}
+     */
+    automations?: AutomationCapabilities;
+}
+/**
+ * Automation features supported by this host authority.
+ *
+ * The presence of this object advertises the baseline `ahp-automations://`
+ * catalogue. Optional fields describe additional host features and
+ * restrictions.
+ *
+ * Capabilities describe implementation support.
+ * {@link AutomationEntry.operations} remains authoritative for which
+ * definition mutations are currently allowed on a particular automation.
+ *
+ * @category Commands
+ */
+export interface AutomationCapabilities {
+    /** Present when clients may dispatch {@link AutomationCreateRequestedAction}. */
+    create?: AutomationCreateCapability;
+    /** Present when definitions may contain {@link AutomationScheduleTrigger | schedule triggers}. */
+    schedules?: AutomationScheduleCapabilities;
+    /**
+     * Present when clients may request cancellation of `pending` or `running`
+     * automation runs.
+     */
+    runCancellation?: AutomationRunCancellationCapability;
+    /**
+     * Maximum terminal entries retained in {@link AutomationEntry.runs}. Active
+     * runs are not counted toward the limit. Absence means the retention limit is
+     * implementation-defined.
+     */
+    runHistoryLimit?: number;
+}
+/**
+ * Presence capability for {@link AutomationCreateRequestedAction |
+ * `automation/createRequested`}.
+ *
+ * The empty object means "supported"; fields are reserved for future
+ * create-specific options.
+ *
+ * @category Commands
+ */
+export interface AutomationCreateCapability {
+}
+/**
+ * Host restrictions on portable {@link AutomationSchedule} triggers.
+ *
+ * The cron grammar itself is fixed by AHP. Hosts MUST accept every expression
+ * in that grammar unless it violates an advertised interval restriction.
+ *
+ * @category Commands
+ */
+export interface AutomationScheduleCapabilities {
+    /**
+     * Smallest permitted interval between consecutive occurrences produced by
+     * {@link AutomationSchedule.expression}. Omission means no restriction beyond
+     * the cron format's one-minute resolution.
+     */
+    minIntervalMinutes?: number;
+}
+/**
+ * Presence capability for {@link AutomationRunCancelRequestedAction |
+ * `automationRun/cancelRequested`}.
+ *
+ * The empty object means "supported." Clients may dispatch the action for
+ * `pending` or `running` runs; terminal runs cannot be cancelled.
+ *
+ * @category Commands
+ */
+export interface AutomationRunCancellationCapability {
 }
 /**
  * Verifies that the AHP connection is still alive and keeps it from being
@@ -143,7 +344,7 @@ export interface InitializeResult {
  * @method ping
  * @direction Client → Server
  * @messageType Request
- * @version 0.1.0
+ * @version 1
  */
 export interface PingParams extends BaseParams {
     channel: "ahp-root://";
@@ -152,6 +353,7 @@ export interface PingParams extends BaseParams {
  * Discriminant for reconnect result types.
  *
  * @category Commands
+ * @exhaustive
  */
 export declare enum ReconnectResultType {
     Replay = "replay",
@@ -222,6 +424,53 @@ export type ReconnectResult = ReconnectReplayResult | ReconnectSnapshotResult;
  * @see {@link /specification/subscriptions | Subscriptions}
  */
 export interface SubscribeParams extends BaseParams {
+    /**
+     * Optional delivery preferences for this subscription.
+     *
+     * Servers MAY use these preferences to buffer and coalesce high-frequency
+     * updates while preserving the same reduced state. Omit this field for the
+     * server's default delivery behavior.
+     */
+    delivery?: SubscriptionDeliveryOptions;
+    /**
+     * Optional client-requested shape for the returned snapshot.
+     *
+     * Servers that do not understand a requested view ignore it and return their
+     * default snapshot. Clients MUST tolerate receiving more state than requested.
+     */
+    view?: SubscribeView;
+}
+/**
+ * Optional client-requested shape for a subscription snapshot.
+ *
+ * @category Commands
+ */
+export interface SubscribeView {
+    /**
+     * Advisory number of most-recent completed turns to expose in a chat
+     * snapshot.
+     *
+     * Servers MAY return more or fewer turns than requested. When omitted, the
+     * host MUST return all retained turns. When older turns remain available, the
+     * returned {@link ChatState} carries `turnsNextCursor`; clients pass that
+     * cursor to `fetchTurns` to ask the host to page more turns into the chat
+     * state.
+     */
+    turns?: number;
+}
+/**
+ * Advisory delivery preferences for a single subscription.
+ *
+ * @category Commands
+ */
+export interface SubscriptionDeliveryOptions {
+    /**
+     * Maximum time, in milliseconds, that the server may intentionally delay
+     * delivery while buffering/coalescing updates for this subscription.
+     *
+     * A value of `0` requests immediate delivery with no intentional coalescing.
+     */
+    maxLatencyMs?: number;
 }
 /**
  * Result of the `subscribe` command.
@@ -275,6 +524,7 @@ export interface DispatchActionParams {
  * Encoding of fetched content data.
  *
  * @category Commands
+ * @exhaustive
  */
 export declare enum ContentEncoding {
     Base64 = "base64",
@@ -360,6 +610,7 @@ export interface ResourceReadResult {
  *   the file — use `truncate` to overwrite bytes in place.
  *
  * @category Commands
+ * @exhaustive
  */
 export declare enum ResourceWriteMode {
     Truncate = "truncate",
@@ -648,6 +899,7 @@ export interface ResourceMoveResult {
  * Discriminant for {@link ResourceResolveResult.type}.
  *
  * @category Commands
+ * @nonexhaustive
  */
 export declare enum ResourceType {
     File = "file",
@@ -764,8 +1016,13 @@ export interface ResourceMkdirResult {
 }
 /**
  * Pushes a Bearer token for a protected resource. The `resource` field MUST
- * match a `ProtectedResourceMetadata.resource` value declared by an agent
- * in `AgentInfo.protectedResources`.
+ * match a protected-resource identifier the client has discovered from the
+ * server — whether declared statically in `AgentInfo.protectedResources`,
+ * or discovered dynamically from a live `McpServerAuthRequiredState.resource`
+ * or `ToolCallAuthRequiredState.auth.resource` (both surfaced only once the
+ * corresponding MCP server or tool call actually challenges for auth).
+ * Servers MUST accept any `resource` value they have themselves advertised
+ * through one of these three mechanisms.
  *
  * Tokens are delivered using [RFC 6750](https://datatracker.ietf.org/doc/html/rfc6750)
  * (Bearer Token Usage) semantics. The client obtains the token from the
@@ -782,7 +1039,8 @@ export interface ResourceMkdirResult {
  * ```jsonc
  * // Client → Server
  * { "jsonrpc": "2.0", "id": 3, "method": "authenticate",
- *   "params": { "channel": "ahp-root://", "resource": "https://api.github.com", "token": "gho_xxxx" } }
+ *   "params": { "channel": "ahp-root://", "resource": "https://api.github.com",
+ *     "token": "gho_xxxx", "expiresIn": 3540 } }
  *
  * // Server → Client (success)
  * { "jsonrpc": "2.0", "id": 3, "result": {} }
@@ -794,12 +1052,40 @@ export interface ResourceMkdirResult {
 export interface AuthenticateParams extends BaseParams {
     channel: "ahp-root://";
     /**
-     * The protected resource identifier. MUST match a `resource` value from
-     * `ProtectedResourceMetadata` declared in `AgentInfo.protectedResources`.
+     * The protected resource identifier. MUST match a `resource` value the
+     * server has advertised — via `ProtectedResourceMetadata` in
+     * `AgentInfo.protectedResources`, or via a live
+     * `McpServerAuthRequiredState.resource` / `ToolCallAuthRequiredState.auth.resource`.
      */
     resource: string;
     /** Bearer token obtained from the resource's authorization server */
     token: string;
+    /**
+     * The access token's remaining lifetime, in seconds, when this
+     * `authenticate` request is sent. This corresponds to `expires_in` in an
+     * OAuth 2.0 token response (RFC 6749 section 5.1).
+     *
+     * If the client retained the original token response, it MUST subtract the
+     * elapsed time before forwarding this value. Omit this field when the
+     * authorization server did not supply an expiry or the expiry is otherwise
+     * unknown. When supplied, the value MUST be a positive integer.
+     *
+     * This field is irrelevant when `token` is empty to revoke authentication
+     * and SHOULD be omitted in that case.
+     *
+     * @integer
+     * @minimum 1
+     */
+    expiresIn?: number;
+    /**
+     * OAuth scopes the token grants, when known. Lets the server determine
+     * whether a specific challenge — e.g. the `requiredScopes` on a live
+     * `McpServerAuthRequiredState` or `ToolCallAuthRequiredState.auth` — is
+     * satisfied without decoding the (opaque, server-specific) token itself.
+     * Omit when the client doesn't track granted scopes separately from the
+     * token.
+     */
+    scopes?: string[];
 }
 /**
  * Result of the `authenticate` command.

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

@@ -0,0 +1,186 @@
+import type { ProtectedResourceMetadata } from "./state.js";
+import type { ResourceRequestParams } from "./commands.js";
+/**
+ * Standard JSON-RPC 2.0 error codes.
+ *
+ * @category Standard JSON-RPC Codes
+ */
+export declare const JsonRpcErrorCodes: {
+    /** Invalid JSON */
+    readonly ParseError: -32700;
+    /** Not a valid JSON-RPC request */
+    readonly InvalidRequest: -32600;
+    /** Unknown method name */
+    readonly MethodNotFound: -32601;
+    /** Invalid method parameters */
+    readonly InvalidParams: -32602;
+    /** Unspecified server error */
+    readonly InternalError: -32603;
+};
+/**
+ * AHP application-specific error codes.
+ *
+ * @category AHP Application Codes
+ * @version 1
+ */
+export declare const AhpErrorCodes: {
+    /** The referenced session URI does not exist */
+    readonly SessionNotFound: -32001;
+    /** The requested agent provider is not registered */
+    readonly ProviderNotFound: -32002;
+    /** A session with the given URI already exists */
+    readonly SessionAlreadyExists: -32003;
+    /** The operation requires no active turn, but one is in progress */
+    readonly TurnInProgress: -32004;
+    /**
+     * The server cannot speak any of the protocol versions offered by the
+     * client in `InitializeParams.protocolVersions`. The `data` field of the
+     * JSON-RPC error MUST carry an `UnsupportedProtocolVersionErrorData`
+     * advertising the protocol versions the server is willing to speak.
+     */
+    readonly UnsupportedProtocolVersion: -32005;
+    /**
+     * A command failed because the client has not authenticated for a required
+     * protected resource. The `data` field of the JSON-RPC error MUST be an
+     * `AuthRequiredErrorData` describing the resources that require
+     * authentication.
+     *
+     * @see {@link /specification/authentication | Authentication}
+     */
+    readonly AuthRequired: -32007;
+    /** The requested file, folder, or URI does not exist */
+    readonly NotFound: -32008;
+    /**
+     * The client is not permitted to access the requested resource.
+     *
+     * Servers SHOULD return this when a client attempts to read or browse
+     * a path outside the allowed set (e.g. outside the session's working
+     * directory or workspace roots).
+     *
+     * The `data` field of the JSON-RPC error MAY be a
+     * `PermissionDeniedErrorData` advertising a `resourceRequest` that, if
+     * granted, would unlock the operation.
+     */
+    readonly PermissionDenied: -32009;
+    /**
+     * The target resource already exists and the operation does not allow
+     * overwriting (e.g. `resourceWrite` with `createOnly: true`).
+     */
+    readonly AlreadyExists: -32010;
+    /**
+     * An optimistic-concurrency precondition failed.
+     *
+     * Returned when a request carries a precondition token that no longer
+     * matches the receiver's current state — for example, `resourceWrite`
+     * with an `ifMatch` etag that has been superseded by a concurrent
+     * write. Callers SHOULD re-read the resource (e.g. via
+     * `resourceResolve`) and decide whether to retry the operation with the
+     * fresh token or surface the conflict to the user.
+     */
+    readonly Conflict: -32011;
+};
+/** Union type of all AHP application error codes. */
+export type AhpErrorCode = (typeof AhpErrorCodes)[keyof typeof AhpErrorCodes];
+/** Union type of all JSON-RPC error codes. */
+export type JsonRpcErrorCode = (typeof JsonRpcErrorCodes)[keyof typeof JsonRpcErrorCodes];
+/**
+ * Details carried in the `data` field of an `AuthRequired` (-32007) error.
+ *
+ * Wraps the protected resource list in `{ resources: [...] }` rather than
+ * returning a bare array, so additional fields can be added in future
+ * versions without breaking the wire shape.
+ *
+ * @category Error Details
+ * @version 1
+ */
+export interface AuthRequiredErrorData {
+    /** Protected resources that require authentication. */
+    resources: ProtectedResourceMetadata[];
+}
+/**
+ * Details carried in the `data` field of a `PermissionDenied` (-32009) error.
+ *
+ * The receiver MAY advertise a `resourceRequest` payload describing the
+ * access that, if granted, would unlock the operation. The caller MAY then
+ * issue `resourceRequest` with that payload to negotiate access.
+ *
+ * @category Error Details
+ * @version 1
+ */
+export interface PermissionDeniedErrorData {
+    /**
+     * The resource access that, if granted via `resourceRequest`, would unlock
+     * the operation. Omitted when no specific access grant would resolve the
+     * denial (for example, when the resource is fundamentally inaccessible).
+     */
+    request?: ResourceRequestParams;
+}
+/**
+ * Details carried in the `data` field of an `UnsupportedProtocolVersion`
+ * (-32005) error.
+ *
+ * The data payload is required and always carries `supportedVersions`.
+ *
+ * @category Error Details
+ * @version 1
+ */
+export interface UnsupportedProtocolVersionErrorData {
+    /**
+     * Protocol versions the server is willing to speak.
+     *
+     * Each entry is either a [SemVer](https://semver.org) `MAJOR.MINOR.PATCH`
+     * string (e.g. `"0.1.0"`) or a [SemVer range](https://semver.org/#spec-item-11)
+     * constraint (e.g. `">=0.1.0 <0.3.0"` or `"^0.2.0"`).
+     */
+    supportedVersions: string[];
+}
+/**
+ * Maps each AHP error code that carries structured `data` to the type of
+ * that data.
+ *
+ * Error codes not present in this map either have no `data` payload or
+ * carry an unspecified payload that callers SHOULD treat as `unknown`.
+ *
+ * @category Error Details
+ * @version 1
+ */
+export interface AhpErrorDetailsMap {
+    [AhpErrorCodes.AuthRequired]: AuthRequiredErrorData;
+    [AhpErrorCodes.PermissionDenied]: PermissionDeniedErrorData;
+    [AhpErrorCodes.UnsupportedProtocolVersion]: UnsupportedProtocolVersionErrorData;
+}
+/** AHP error codes that carry a structured `data` payload. */
+export type AhpErrorCodeWithData = keyof AhpErrorDetailsMap;
+/**
+ * A typed JSON-RPC error object whose `data` is narrowed by `code`.
+ *
+ * Distributes over the `AhpErrorCode` union so narrowing on `code` reveals
+ * the precise `data` type. For codes listed in {@link AhpErrorDetailsMap}
+ * `data` is required; for all other codes `data` is an optional `unknown`.
+ *
+ * ```ts
+ * function handle(err: AhpError) {
+ *   if (err.code === AhpErrorCodes.PermissionDenied) {
+ *     err.data.request; // typed as ResourceRequestParams | undefined
+ *   }
+ * }
+ * ```
+ *
+ * @category Error Details
+ * @version 1
+ */
+export type AhpError<C extends AhpErrorCode = AhpErrorCode> = C extends AhpErrorCode ? C extends keyof AhpErrorDetailsMap ? {
+    /** The error code. */
+    readonly code: C;
+    /** Human-readable error message. */
+    readonly message: string;
+    /** Structured detail payload mandated by `AhpErrorDetailsMap`. */
+    readonly data: AhpErrorDetailsMap[C];
+} : {
+    /** The error code. */
+    readonly code: C;
+    /** Human-readable error message. */
+    readonly message: string;
+    /** Optional, unspecified detail payload. */
+    readonly data?: unknown;
+} : never;

package/vscode/src/vs/platform/agentHost/common/state/protocol/common/errors.js

@@ -0,0 +1,11 @@
+
+
+const JsonRpcErrorCodes = {
+    InvalidParams: -32602};
+const AhpErrorCodes = {
+    UnsupportedProtocolVersion: -32005,
+    NotFound: -32008,
+    PermissionDenied: -32009,
+    AlreadyExists: -32010};
+
+export { AhpErrorCodes, JsonRpcErrorCodes };

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

@@ -5,11 +5,12 @@ import type { CreateChatParams, DisposeChatParams } from "../channels-chat/comma
 import type { CreateTerminalParams, DisposeTerminalParams } from "../channels-terminal/commands.js";
 import type { CreateResourceWatchParams, CreateResourceWatchResult } from "../channels-resource-watch/commands.js";
 import type { InvokeChangesetOperationParams, InvokeChangesetOperationResult } from "../channels-changeset/commands.js";
+import type { ListAutomationTriggerDefinitionsParams, ListAutomationTriggerDefinitionsResult, RunAutomationParams, RunAutomationResult, FetchAutomationRunsParams, FetchAutomationRunsResult } from "../channels-automation/commands.js";
 import type { ActionEnvelope } from "./actions.js";
 import type { SessionAddedParams, SessionRemovedParams, SessionSummaryChangedParams, ProgressParams } from "../channels-root/notifications.js";
-import type { AuthRequiredParams } from "@codingame/monaco-vscode-xterm-common/vscode/vs/platform/agentHost/common/state/protocol/common/notifications";
+import type { AuthRequiredParams } from "./notifications.js";
 import type { OtlpExportLogsParams, OtlpExportTracesParams, OtlpExportMetricsParams } from "../channels-otlp/notifications.js";
-import type { AhpError } from "@codingame/monaco-vscode-chat-service-override/vscode/vs/platform/agentHost/common/state/protocol/common/errors";
+import type { AhpError } from "./errors.js";
 /** A JSON-RPC request: has both `method` and `id`. */
 export interface JsonRpcRequest {
     readonly jsonrpc: "2.0";
@@ -169,6 +170,18 @@ export interface CommandMap {
         params: InvokeChangesetOperationParams;
         result: InvokeChangesetOperationResult;
     };
+    "listAutomationTriggerDefinitions": {
+        params: ListAutomationTriggerDefinitionsParams;
+        result: ListAutomationTriggerDefinitionsResult;
+    };
+    "runAutomation": {
+        params: RunAutomationParams;
+        result: RunAutomationResult;
+    };
+    "fetchAutomationRuns": {
+        params: FetchAutomationRunsParams;
+        result: FetchAutomationRunsResult;
+    };
 }
 /**
  * Registry mapping each server → client request method to its params and
@@ -319,8 +332,8 @@ export type AhpServerRequest<M extends keyof ServerCommandMap = keyof ServerComm
  * generic parameter when you know the method from the associated request:
  *
  * ```ts
- * const result: AhpSuccessResponse<'fetchTurns'> = ...;
- * result.result.turns; // typed as Turn[]
+ * const result: AhpSuccessResponse<'listSessions'> = ...;
+ * result.result.items; // typed as SessionSummary[]
  * ```
  */
 export type AhpSuccessResponse<M extends keyof CommandMap = keyof CommandMap> = M extends unknown ? {