@codingame/monaco-vscode-api 33.0.9 → 34.0.0

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

@@ -0,0 +1,26 @@
+
+
+var ReconnectResultType;
+(function (ReconnectResultType) {
+    ReconnectResultType["Replay"] = "replay";
+    ReconnectResultType["Snapshot"] = "snapshot";
+})(ReconnectResultType || (ReconnectResultType = {}));
+var ContentEncoding;
+(function (ContentEncoding) {
+    ContentEncoding["Base64"] = "base64";
+    ContentEncoding["Utf8"] = "utf-8";
+})(ContentEncoding || (ContentEncoding = {}));
+var ResourceWriteMode;
+(function (ResourceWriteMode) {
+    ResourceWriteMode["Truncate"] = "truncate";
+    ResourceWriteMode["Append"] = "append";
+    ResourceWriteMode["Insert"] = "insert";
+})(ResourceWriteMode || (ResourceWriteMode = {}));
+var ResourceType;
+(function (ResourceType) {
+    ResourceType["File"] = "file";
+    ResourceType["Directory"] = "directory";
+    ResourceType["Symlink"] = "symlink";
+})(ResourceType || (ResourceType = {}));
+
+export { ContentEncoding, ReconnectResultType, ResourceType, ResourceWriteMode };

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

@@ -0,0 +1,373 @@
+import type { InitializeParams, InitializeResult, PingParams, ReconnectParams, ReconnectResult, SubscribeParams, SubscribeResult, ResourceReadParams, ResourceReadResult, ResourceWriteParams, ResourceWriteResult, ResourceListParams, ResourceListResult, ResourceCopyParams, ResourceCopyResult, ResourceDeleteParams, ResourceDeleteResult, ResourceMoveParams, ResourceMoveResult, ResourceResolveParams, ResourceResolveResult, ResourceMkdirParams, ResourceMkdirResult, ResourceRequestParams, ResourceRequestResult, UnsubscribeParams, DispatchActionParams, AuthenticateParams, AuthenticateResult } from "./commands.js";
+import type { ListSessionsParams, ListSessionsResult, ResolveSessionConfigParams, ResolveSessionConfigResult, SessionConfigCompletionsParams, SessionConfigCompletionsResult } from "../channels-root/commands.js";
+import type { CreateSessionParams, DisposeSessionParams, FetchTurnsParams, FetchTurnsResult, CompletionsParams, CompletionsResult } from "../channels-session/commands.js";
+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 { ActionEnvelope } from "./actions.js";
+import type { SessionAddedParams, SessionRemovedParams, SessionSummaryChangedParams } 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 { 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";
+/** A JSON-RPC request: has both `method` and `id`. */
+export interface JsonRpcRequest {
+    readonly jsonrpc: "2.0";
+    readonly id: number;
+    readonly method: string;
+    readonly params?: unknown;
+}
+/** A JSON-RPC success response. */
+export interface JsonRpcSuccessResponse {
+    readonly jsonrpc: "2.0";
+    readonly id: number;
+    readonly result: unknown;
+}
+/** A JSON-RPC error response. */
+export interface JsonRpcErrorResponse {
+    readonly jsonrpc: "2.0";
+    readonly id: number;
+    readonly error: {
+        readonly code: number;
+        readonly message: string;
+        readonly data?: unknown;
+    };
+}
+/**
+ * A typed JSON-RPC error response whose error object is a fully typed
+ * {@link AhpError}. Useful when the caller knows the response is an AHP
+ * application error and wants `data` narrowed by `code`.
+ */
+export interface AhpErrorResponse {
+    readonly jsonrpc: "2.0";
+    readonly id: number;
+    readonly error: AhpError;
+}
+/** A JSON-RPC response (success or error). */
+export type JsonRpcResponse = JsonRpcSuccessResponse | JsonRpcErrorResponse;
+/** A JSON-RPC notification: has `method` but no `id`. */
+export interface JsonRpcNotification {
+    readonly jsonrpc: "2.0";
+    readonly method: string;
+    readonly params?: unknown;
+}
+/**
+ * Registry mapping each command method name to its params and result types.
+ *
+ * `CommandMap` covers methods that the client sends to the server. Methods
+ * that may also be initiated by the server are duplicated in
+ * {@link ServerCommandMap}; the entries in the two maps are kept identical.
+ *
+ * @category Commands
+ */
+export interface CommandMap {
+    "initialize": {
+        params: InitializeParams;
+        result: InitializeResult;
+    };
+    "ping": {
+        params: PingParams;
+        result: null;
+    };
+    "reconnect": {
+        params: ReconnectParams;
+        result: ReconnectResult;
+    };
+    "subscribe": {
+        params: SubscribeParams;
+        result: SubscribeResult;
+    };
+    "createSession": {
+        params: CreateSessionParams;
+        result: null;
+    };
+    "disposeSession": {
+        params: DisposeSessionParams;
+        result: null;
+    };
+    "createTerminal": {
+        params: CreateTerminalParams;
+        result: null;
+    };
+    "disposeTerminal": {
+        params: DisposeTerminalParams;
+        result: null;
+    };
+    "createResourceWatch": {
+        params: CreateResourceWatchParams;
+        result: CreateResourceWatchResult;
+    };
+    "listSessions": {
+        params: ListSessionsParams;
+        result: ListSessionsResult;
+    };
+    "resourceRead": {
+        params: ResourceReadParams;
+        result: ResourceReadResult;
+    };
+    "resourceWrite": {
+        params: ResourceWriteParams;
+        result: ResourceWriteResult;
+    };
+    "resourceList": {
+        params: ResourceListParams;
+        result: ResourceListResult;
+    };
+    "resourceCopy": {
+        params: ResourceCopyParams;
+        result: ResourceCopyResult;
+    };
+    "resourceDelete": {
+        params: ResourceDeleteParams;
+        result: ResourceDeleteResult;
+    };
+    "resourceMove": {
+        params: ResourceMoveParams;
+        result: ResourceMoveResult;
+    };
+    "resourceResolve": {
+        params: ResourceResolveParams;
+        result: ResourceResolveResult;
+    };
+    "resourceMkdir": {
+        params: ResourceMkdirParams;
+        result: ResourceMkdirResult;
+    };
+    "resourceRequest": {
+        params: ResourceRequestParams;
+        result: ResourceRequestResult;
+    };
+    "fetchTurns": {
+        params: FetchTurnsParams;
+        result: FetchTurnsResult;
+    };
+    "authenticate": {
+        params: AuthenticateParams;
+        result: AuthenticateResult;
+    };
+    "resolveSessionConfig": {
+        params: ResolveSessionConfigParams;
+        result: ResolveSessionConfigResult;
+    };
+    "sessionConfigCompletions": {
+        params: SessionConfigCompletionsParams;
+        result: SessionConfigCompletionsResult;
+    };
+    "completions": {
+        params: CompletionsParams;
+        result: CompletionsResult;
+    };
+    "invokeChangesetOperation": {
+        params: InvokeChangesetOperationParams;
+        result: InvokeChangesetOperationResult;
+    };
+}
+/**
+ * Registry mapping each server → client request method to its params and
+ * result types.
+ *
+ * The `resource*` family is symmetrical: every method that appears in
+ * {@link CommandMap} also appears here with the identical params/result
+ * shape, and the receiver decides whether to allow, deny, or prompt for
+ * the requested operation regardless of which peer initiated. Hosts use
+ * the reverse direction to read from client-published URIs (e.g.
+ * `virtual://my-client/...` plugins) and to drive per-session filesystem
+ * providers without the client having to re-implement the wire schema.
+ *
+ * @category Commands
+ */
+export interface ServerCommandMap {
+    "resourceRead": {
+        params: ResourceReadParams;
+        result: ResourceReadResult;
+    };
+    "resourceWrite": {
+        params: ResourceWriteParams;
+        result: ResourceWriteResult;
+    };
+    "resourceList": {
+        params: ResourceListParams;
+        result: ResourceListResult;
+    };
+    "resourceCopy": {
+        params: ResourceCopyParams;
+        result: ResourceCopyResult;
+    };
+    "resourceDelete": {
+        params: ResourceDeleteParams;
+        result: ResourceDeleteResult;
+    };
+    "resourceMove": {
+        params: ResourceMoveParams;
+        result: ResourceMoveResult;
+    };
+    "resourceResolve": {
+        params: ResourceResolveParams;
+        result: ResourceResolveResult;
+    };
+    "resourceMkdir": {
+        params: ResourceMkdirParams;
+        result: ResourceMkdirResult;
+    };
+    "resourceRequest": {
+        params: ResourceRequestParams;
+        result: ResourceRequestResult;
+    };
+    "createResourceWatch": {
+        params: CreateResourceWatchParams;
+        result: CreateResourceWatchResult;
+    };
+}
+/**
+ * Registry mapping each client → server notification method to its params type.
+ *
+ * Every notification's params MUST carry a top-level `channel: URI` so that
+ * the server can route the message to the correct subscription. See
+ * {@link UnsubscribeParams} for the canonical "base" shape.
+ *
+ * @category Notifications
+ */
+export interface ClientNotificationMap {
+    "unsubscribe": {
+        params: UnsubscribeParams;
+    };
+    "dispatchAction": {
+        params: DispatchActionParams;
+    };
+}
+/**
+ * Registry mapping each server → client notification method to its params type.
+ *
+ * Every notification's params MUST carry a top-level `channel: URI` so that
+ * the client can dispatch the message to the right subscription.
+ *
+ * @category Notifications
+ */
+export interface ServerNotificationMap {
+    "action": {
+        params: ActionEnvelope;
+    };
+    "root/sessionAdded": {
+        params: SessionAddedParams;
+    };
+    "root/sessionRemoved": {
+        params: SessionRemovedParams;
+    };
+    "root/sessionSummaryChanged": {
+        params: SessionSummaryChangedParams;
+    };
+    "auth/required": {
+        params: AuthRequiredParams;
+    };
+    "otlp/exportLogs": {
+        params: OtlpExportLogsParams;
+    };
+    "otlp/exportTraces": {
+        params: OtlpExportTracesParams;
+    };
+    "otlp/exportMetrics": {
+        params: OtlpExportMetricsParams;
+    };
+}
+/**
+ * A fully typed JSON-RPC request for a specific AHP command.
+ *
+ * When used as a union (default generic), narrowing on `method` gives typed `params`:
+ *
+ * ```ts
+ * function handle(req: AhpRequest) {
+ *   if (req.method === 'fetchTurns') {
+ *     req.params.session; // typed as URI
+ *   }
+ * }
+ * ```
+ *
+ * Defaults to client → server requests ({@link CommandMap}). Use
+ * {@link AhpServerRequest} for server → client requests.
+ */
+export type AhpRequest<M extends keyof CommandMap = keyof CommandMap> = M extends unknown ? {
+    readonly jsonrpc: "2.0";
+    readonly id: number;
+    readonly method: M;
+    readonly params: CommandMap[M]["params"];
+} : never;
+/**
+ * A fully typed JSON-RPC request initiated by the server. Identical in shape
+ * to {@link AhpRequest} but parameterised over {@link ServerCommandMap}.
+ */
+export type AhpServerRequest<M extends keyof ServerCommandMap = keyof ServerCommandMap> = M extends unknown ? {
+    readonly jsonrpc: "2.0";
+    readonly id: number;
+    readonly method: M;
+    readonly params: ServerCommandMap[M]["params"];
+} : never;
+/**
+ * A fully typed JSON-RPC success response for a specific AHP command.
+ *
+ * Since JSON-RPC responses do not carry `method`, use this with an explicit
+ * generic parameter when you know the method from the associated request:
+ *
+ * ```ts
+ * const result: AhpSuccessResponse<'fetchTurns'> = ...;
+ * result.result.turns; // typed as Turn[]
+ * ```
+ */
+export type AhpSuccessResponse<M extends keyof CommandMap = keyof CommandMap> = M extends unknown ? {
+    readonly jsonrpc: "2.0";
+    readonly id: number;
+    readonly result: CommandMap[M]["result"];
+} : never;
+/** Typed JSON-RPC response (success with known result type, or error). */
+export type AhpResponse<M extends keyof CommandMap = keyof CommandMap> = AhpSuccessResponse<M> | JsonRpcErrorResponse;
+/**
+ * A fully typed JSON-RPC success response for a server → client request
+ * ({@link ServerCommandMap}).
+ */
+export type AhpServerSuccessResponse<M extends keyof ServerCommandMap = keyof ServerCommandMap> = M extends unknown ? {
+    readonly jsonrpc: "2.0";
+    readonly id: number;
+    readonly result: ServerCommandMap[M]["result"];
+} : never;
+/** Typed JSON-RPC response to a server → client request. */
+export type AhpServerResponse<M extends keyof ServerCommandMap = keyof ServerCommandMap> = AhpServerSuccessResponse<M> | JsonRpcErrorResponse;
+/** A client → server notification. */
+export type AhpClientNotification<M extends keyof ClientNotificationMap = keyof ClientNotificationMap> = M extends unknown ? {
+    readonly jsonrpc: "2.0";
+    readonly method: M;
+    readonly params: ClientNotificationMap[M]["params"];
+} : never;
+/** A server → client notification. */
+export type AhpServerNotification<M extends keyof ServerNotificationMap = keyof ServerNotificationMap> = M extends unknown ? {
+    readonly jsonrpc: "2.0";
+    readonly method: M;
+    readonly params: ServerNotificationMap[M]["params"];
+} : never;
+/**
+ * A fully typed JSON-RPC notification — either direction.
+ *
+ * The client → server `dispatchAction` method and the server → client
+ * `action` method are distinct entries in the registries; their params have
+ * unrelated shapes ({@link DispatchActionParams} vs {@link ActionEnvelope}).
+ */
+export type AhpNotification = AhpClientNotification | AhpServerNotification;
+/**
+ * Discriminated union of all AHP protocol messages.
+ *
+ * Narrow using standard JSON-RPC structure:
+ * - Has `method` + `id` → request ({@link AhpRequest} or {@link AhpServerRequest})
+ * - Has `method`, no `id` → notification ({@link AhpNotification})
+ * - Has `result` or `error` + `id` → response ({@link AhpResponse})
+ *
+ * Then narrow on `method` for fully typed params:
+ *
+ * ```ts
+ * function dispatch(msg: ProtocolMessage) {
+ *   if ('method' in msg && 'id' in msg) {
+ *     // msg is AhpRequest | AhpServerRequest
+ *     if (msg.method === 'fetchTurns') {
+ *       msg.params.session; // URI
+ *     }
+ *   }
+ * }
+ * ```
+ */
+export type ProtocolMessage = AhpRequest | AhpServerRequest | AhpSuccessResponse | AhpServerSuccessResponse | JsonRpcErrorResponse | AhpNotification;

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

@@ -0,0 +1,278 @@
+import type { RootState } from "../channels-root/state.js";
+import type { SessionState } from "../channels-session/state.js";
+import type { TerminalState } from "../channels-terminal/state.js";
+import type { ChangesetState } from "../channels-changeset/state.js";
+import type { ResourceWatchState } from "../channels-resource-watch/state.js";
+/** A URI string (e.g. `ahp-root://` or `ahp-session:/<uuid>`). */
+export type URI = string;
+/**
+ * A string that may optionally be rendered as Markdown.
+ *
+ * - A plain `string` is rendered as-is (no Markdown processing).
+ * - An object with `{ markdown: string }` is rendered with Markdown formatting.
+ */
+export type StringOrMarkdown = string | {
+    markdown: string;
+};
+/**
+ * An optionally-sized icon that can be displayed in a user interface.
+ *
+ * @category Common Types
+ */
+export interface Icon {
+    /**
+     * A standard URI pointing to an icon resource. May be an HTTP/HTTPS URL or a
+     * `data:` URI with Base64-encoded image data.
+     *
+     * Consumers SHOULD take steps to ensure URLs serving icons are from the
+     * same domain as the client/server or a trusted domain.
+     *
+     * Consumers SHOULD take appropriate precautions when consuming SVGs as they can contain
+     * executable JavaScript.
+     */
+    src: URI;
+    /**
+     * Optional MIME type override if the source MIME type is missing or generic.
+     * For example: `"image/png"`, `"image/jpeg"`, or `"image/svg+xml"`.
+     */
+    contentType?: string;
+    /**
+     * Optional array of strings that specify sizes at which the icon can be used.
+     * Each string should be in WxH format (e.g., `"48x48"`, `"96x96"`) or `"any"` for scalable formats like SVG.
+     *
+     * If not provided, the client should assume that the icon can be used at any size.
+     */
+    sizes?: string[];
+    /**
+     * Optional specifier for the theme this icon is designed for. `"light"` indicates
+     * the icon is designed to be used with a light background, and `"dark"` indicates
+     * the icon is designed to be used with a dark background.
+     *
+     * If not provided, the client should assume the icon can be used with any theme.
+     */
+    theme?: "light" | "dark";
+}
+/**
+ * Describes a protected resource's authentication requirements using
+ * [RFC 9728](https://datatracker.ietf.org/doc/html/rfc9728) (OAuth 2.0
+ * Protected Resource Metadata) semantics.
+ *
+ * Field names use snake_case to match the RFC 9728 JSON format.
+ *
+ * @category Authentication
+ * @see {@link https://datatracker.ietf.org/doc/html/rfc9728 | RFC 9728}
+ */
+export interface ProtectedResourceMetadata {
+    /**
+     * REQUIRED. The protected resource's resource identifier, a URL using the
+     * `https` scheme with no fragment component (e.g. `"https://api.github.com"`).
+     */
+    resource: string;
+    /** OPTIONAL. Human-readable name of the protected resource. */
+    resource_name?: string;
+    /** OPTIONAL. JSON array of OAuth authorization server identifier URLs. */
+    authorization_servers?: string[];
+    /** OPTIONAL. URL of the protected resource's JWK Set document. */
+    jwks_uri?: string;
+    /** RECOMMENDED. JSON array of OAuth 2.0 scope values used in authorization requests. */
+    scopes_supported?: string[];
+    /** OPTIONAL. JSON array of Bearer Token presentation methods supported. */
+    bearer_methods_supported?: string[];
+    /** OPTIONAL. JSON array of JWS signing algorithms supported. */
+    resource_signing_alg_values_supported?: string[];
+    /** OPTIONAL. JSON array of JWE encryption algorithms (alg) supported. */
+    resource_encryption_alg_values_supported?: string[];
+    /** OPTIONAL. JSON array of JWE encryption algorithms (enc) supported. */
+    resource_encryption_enc_values_supported?: string[];
+    /** OPTIONAL. URL of human-readable documentation for the resource. */
+    resource_documentation?: string;
+    /** OPTIONAL. URL of the resource's data-usage policy. */
+    resource_policy_uri?: string;
+    /** OPTIONAL. URL of the resource's terms of service. */
+    resource_tos_uri?: string;
+    /**
+     * AHP extension. Whether authentication is required for this resource.
+     *
+     * - `true` (default) — the agent cannot be used without a valid token.
+     *   The server SHOULD return `AuthRequired` (`-32007`) if the client
+     *   attempts to use the agent without authenticating.
+     * - `false` — the agent works without authentication but MAY offer
+     *   enhanced capabilities when a token is provided.
+     *
+     * Clients SHOULD treat an absent field the same as `true`.
+     */
+    required?: boolean;
+}
+/**
+ * A JSON Schema-compatible property descriptor with display extensions.
+ *
+ * Standard JSON Schema fields (`type`, `title`, `description`, `default`,
+ * `enum`) allow validators to process the schema. Display extensions
+ * (`enumLabels`, `enumDescriptions`) are parallel arrays that provide UI
+ * metadata for each `enum` value.
+ *
+ * This is the generic base type. See {@link SessionConfigPropertySchema} for
+ * session-specific extensions.
+ *
+ * @category Config Schema Types
+ */
+export interface ConfigPropertySchema {
+    /** JSON Schema: property type */
+    type: "string" | "number" | "boolean" | "array" | "object";
+    /** JSON Schema: human-readable label for the property */
+    title: string;
+    /** JSON Schema: description / tooltip */
+    description?: string;
+    /** JSON Schema: default value */
+    default?: unknown;
+    /** JSON Schema: allowed values (typically used with `string` type) */
+    enum?: string[];
+    /** Display extension: human-readable label per enum value (parallel array) */
+    enumLabels?: string[];
+    /** Display extension: description per enum value (parallel array) */
+    enumDescriptions?: string[];
+    /** JSON Schema: when `true`, the property is displayed but cannot be modified by the user */
+    readOnly?: boolean;
+    /** JSON Schema: schema for array items (used when `type` is `'array'`) */
+    items?: ConfigPropertySchema;
+    /** JSON Schema: property descriptors for object properties (used when `type` is `'object'`) */
+    properties?: Record<string, ConfigPropertySchema>;
+    /** JSON Schema: list of required property ids (used when `type` is `'object'`) */
+    required?: string[];
+}
+/**
+ * A JSON Schema object describing available configuration properties.
+ *
+ * This is the generic base type. See {@link SessionConfigSchema} for
+ * session-specific usage.
+ *
+ * @category Config Schema Types
+ */
+export interface ConfigSchema {
+    /** JSON Schema: always `'object'` */
+    type: "object";
+    /** JSON Schema: property descriptors keyed by property id */
+    properties: Record<string, ConfigPropertySchema>;
+    /** JSON Schema: list of required property ids */
+    required?: string[];
+}
+/**
+ * A zero-based position within a textual document.
+ *
+ * @category Turn Types
+ */
+export interface TextPosition {
+    /** Zero-based line number. */
+    line: number;
+    /** Zero-based character offset within the line. */
+    character: number;
+}
+/**
+ * A range within a textual document.
+ *
+ * @category Turn Types
+ */
+export interface TextRange {
+    /** Start position of the range. */
+    start: TextPosition;
+    /** End position of the range. */
+    end: TextPosition;
+}
+/**
+ * A selection within a textual resource.
+ *
+ * This is only meaningful for textual resources. Binary resources may still
+ * use resource or embedded resource attachments, but they should not use this
+ * text selection field.
+ *
+ * @category Turn Types
+ */
+export interface TextSelection {
+    /** The range covered by the selection. */
+    range: TextRange;
+}
+/**
+ * A reference to large content stored outside the state tree.
+ */
+export interface ContentRef {
+    /** Content URI */
+    uri: URI;
+    /** Approximate size in bytes */
+    sizeHint?: number;
+    /** Content MIME type */
+    contentType?: string;
+}
+/**
+ * Describes a file modification with before/after state and diff metadata.
+ *
+ * Supports creates (only `after`), deletes (only `before`), renames/moves
+ * (different `uri` in `before` and `after`), and edits (same `uri`, different content).
+ *
+ * @category Tool Result Content
+ */
+export interface FileEdit {
+    /** The file state before the edit. Absent for file creations or for in-place file edits. */
+    before?: {
+        /** URI of the file before the edit */
+        uri: URI;
+        /** Reference to the file content before the edit */
+        content: ContentRef;
+    };
+    /** The file state after the edit. Absent for file deletions. */
+    after?: {
+        /** URI of the file after the edit */
+        uri: URI;
+        /** Reference to the file content after the edit */
+        content: ContentRef;
+    };
+    /** Optional diff display metadata */
+    diff?: {
+        /** Number of items added (e.g., lines for text files, cells for notebooks) */
+        added?: number;
+        /** Number of items removed (e.g., lines for text files, cells for notebooks) */
+        removed?: number;
+    };
+}
+/**
+ * @category Common Types
+ */
+export interface UsageInfo {
+    /** Input tokens consumed */
+    inputTokens?: number;
+    /** Output tokens generated */
+    outputTokens?: number;
+    /** Model used */
+    model?: string;
+    /** Tokens read from cache */
+    cacheReadTokens?: number;
+    /**
+     * Additional provider-specific metadata for this usage report.
+     * Clients MAY look for well-known optional keys here to provide enhanced UI.
+     */
+    _meta?: Record<string, unknown>;
+}
+/**
+ * @category Common Types
+ */
+export interface ErrorInfo {
+    /** Error type identifier */
+    errorType: string;
+    /** Human-readable error message */
+    message: string;
+    /** Stack trace */
+    stack?: string;
+}
+/**
+ * A point-in-time snapshot of a subscribed resource's state, returned by
+ * `initialize`, `reconnect`, and `subscribe`.
+ *
+ * @category Common Types
+ */
+export interface Snapshot {
+    /** The subscribed channel URI (e.g. `ahp-root://` or `ahp-session:/<uuid>`) */
+    resource: URI;
+    /** The current state of the resource */
+    state: RootState | SessionState | TerminalState | ChangesetState | ResourceWatchState;
+    /** The `serverSeq` at which this snapshot was taken. Subsequent actions will have `serverSeq > fromSeq`. */
+    fromSeq: number;
+}

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

@@ -0,0 +1 @@
+export * from "@codingame/monaco-vscode-chat-service-override/vscode/vs/platform/agentHost/common/state/protocol/common/errors";