@codingame/monaco-vscode-api 34.1.3 → 35.0.1

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

@@ -0,0 +1,119 @@
+
+
+var ChatOriginKind;
+(function (ChatOriginKind) {
+    ChatOriginKind["User"] = "user";
+    ChatOriginKind["Fork"] = "fork";
+    ChatOriginKind["Tool"] = "tool";
+})(ChatOriginKind || (ChatOriginKind = {}));
+var ChatInteractivity;
+(function (ChatInteractivity) {
+    ChatInteractivity["Full"] = "full";
+    ChatInteractivity["ReadOnly"] = "read-only";
+    ChatInteractivity["Hidden"] = "hidden";
+})(ChatInteractivity || (ChatInteractivity = {}));
+var PendingMessageKind;
+(function (PendingMessageKind) {
+    PendingMessageKind["Steering"] = "steering";
+    PendingMessageKind["Queued"] = "queued";
+})(PendingMessageKind || (PendingMessageKind = {}));
+var ChatInputResponseKind;
+(function (ChatInputResponseKind) {
+    ChatInputResponseKind["Accept"] = "accept";
+    ChatInputResponseKind["Decline"] = "decline";
+    ChatInputResponseKind["Cancel"] = "cancel";
+})(ChatInputResponseKind || (ChatInputResponseKind = {}));
+var ChatInputQuestionKind;
+(function (ChatInputQuestionKind) {
+    ChatInputQuestionKind["Text"] = "text";
+    ChatInputQuestionKind["Number"] = "number";
+    ChatInputQuestionKind["Integer"] = "integer";
+    ChatInputQuestionKind["Boolean"] = "boolean";
+    ChatInputQuestionKind["SingleSelect"] = "single-select";
+    ChatInputQuestionKind["MultiSelect"] = "multi-select";
+})(ChatInputQuestionKind || (ChatInputQuestionKind = {}));
+var ChatInputAnswerValueKind;
+(function (ChatInputAnswerValueKind) {
+    ChatInputAnswerValueKind["Text"] = "text";
+    ChatInputAnswerValueKind["Number"] = "number";
+    ChatInputAnswerValueKind["Boolean"] = "boolean";
+    ChatInputAnswerValueKind["Selected"] = "selected";
+    ChatInputAnswerValueKind["SelectedMany"] = "selected-many";
+})(ChatInputAnswerValueKind || (ChatInputAnswerValueKind = {}));
+var ChatInputAnswerState;
+(function (ChatInputAnswerState) {
+    ChatInputAnswerState["Draft"] = "draft";
+    ChatInputAnswerState["Submitted"] = "submitted";
+    ChatInputAnswerState["Skipped"] = "skipped";
+})(ChatInputAnswerState || (ChatInputAnswerState = {}));
+var TurnState;
+(function (TurnState) {
+    TurnState["Complete"] = "complete";
+    TurnState["Cancelled"] = "cancelled";
+    TurnState["Error"] = "error";
+})(TurnState || (TurnState = {}));
+var MessageAttachmentKind;
+(function (MessageAttachmentKind) {
+    MessageAttachmentKind["Simple"] = "simple";
+    MessageAttachmentKind["EmbeddedResource"] = "embeddedResource";
+    MessageAttachmentKind["Resource"] = "resource";
+    MessageAttachmentKind["Annotations"] = "annotations";
+})(MessageAttachmentKind || (MessageAttachmentKind = {}));
+var MessageKind;
+(function (MessageKind) {
+    MessageKind["User"] = "user";
+    MessageKind["Agent"] = "agent";
+    MessageKind["Tool"] = "tool";
+    MessageKind["SystemNotification"] = "systemNotification";
+})(MessageKind || (MessageKind = {}));
+var ResponsePartKind;
+(function (ResponsePartKind) {
+    ResponsePartKind["Markdown"] = "markdown";
+    ResponsePartKind["ContentRef"] = "contentRef";
+    ResponsePartKind["ToolCall"] = "toolCall";
+    ResponsePartKind["Reasoning"] = "reasoning";
+    ResponsePartKind["SystemNotification"] = "systemNotification";
+})(ResponsePartKind || (ResponsePartKind = {}));
+var ToolCallStatus;
+(function (ToolCallStatus) {
+    ToolCallStatus["Streaming"] = "streaming";
+    ToolCallStatus["PendingConfirmation"] = "pending-confirmation";
+    ToolCallStatus["Running"] = "running";
+    ToolCallStatus["PendingResultConfirmation"] = "pending-result-confirmation";
+    ToolCallStatus["Completed"] = "completed";
+    ToolCallStatus["Cancelled"] = "cancelled";
+})(ToolCallStatus || (ToolCallStatus = {}));
+var ToolCallConfirmationReason;
+(function (ToolCallConfirmationReason) {
+    ToolCallConfirmationReason["NotNeeded"] = "not-needed";
+    ToolCallConfirmationReason["UserAction"] = "user-action";
+    ToolCallConfirmationReason["Setting"] = "setting";
+})(ToolCallConfirmationReason || (ToolCallConfirmationReason = {}));
+var ToolCallCancellationReason;
+(function (ToolCallCancellationReason) {
+    ToolCallCancellationReason["Denied"] = "denied";
+    ToolCallCancellationReason["Skipped"] = "skipped";
+    ToolCallCancellationReason["ResultDenied"] = "result-denied";
+})(ToolCallCancellationReason || (ToolCallCancellationReason = {}));
+var ConfirmationOptionKind;
+(function (ConfirmationOptionKind) {
+    ConfirmationOptionKind["Approve"] = "approve";
+    ConfirmationOptionKind["Deny"] = "deny";
+})(ConfirmationOptionKind || (ConfirmationOptionKind = {}));
+var ToolCallContributorKind;
+(function (ToolCallContributorKind) {
+    ToolCallContributorKind["Client"] = "client";
+    ToolCallContributorKind["MCP"] = "mcp";
+})(ToolCallContributorKind || (ToolCallContributorKind = {}));
+var ToolResultContentType;
+(function (ToolResultContentType) {
+    ToolResultContentType["Text"] = "text";
+    ToolResultContentType["EmbeddedResource"] = "embeddedResource";
+    ToolResultContentType["Resource"] = "resource";
+    ToolResultContentType["FileEdit"] = "fileEdit";
+    ToolResultContentType["Terminal"] = "terminal";
+    ToolResultContentType["ShellExit"] = "shell_exit";
+    ToolResultContentType["Subagent"] = "subagent";
+})(ToolResultContentType || (ToolResultContentType = {}));
+
+export { ChatInputAnswerState, ChatInputAnswerValueKind, ChatInputQuestionKind, ChatInputResponseKind, ChatInteractivity, ChatOriginKind, ConfirmationOptionKind, MessageAttachmentKind, MessageKind, PendingMessageKind, ResponsePartKind, ToolCallCancellationReason, ToolCallConfirmationReason, ToolCallContributorKind, ToolCallStatus, ToolResultContentType, TurnState };

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

@@ -21,8 +21,8 @@ import type { SessionSummary } from "../channels-session/state.js";
  *       "provider": "copilot",
  *       "title": "New Session",
  *       "status": 1,
- *       "createdAt": 1710000000000,
- *       "modifiedAt": 1710000000000
+ *       "createdAt": "2024-03-09T16:00:00.000Z",
+ *       "modifiedAt": "2024-03-09T16:00:00.000Z"
  *     }
  *   }
  * }
@@ -87,8 +87,7 @@ export interface SessionRemovedParams {
  *   {@link SessionSummary | `SessionSummary`} changes for a session the
  *   server has surfaced via `listSessions()` or `root/sessionAdded`.
  *   Servers MAY coalesce or debounce updates for noisy fields (for example,
- *   `modifiedAt` bumps while a turn is streaming, or rapidly changing
- *   `changesets`) at their discretion.
+ *   `modifiedAt` bumps while a turn is streaming) at their discretion.
  * - Clients that have no cached entry for `session` MAY ignore the
  *   notification; it is not a substitute for `root/sessionAdded`.
  *
@@ -108,7 +107,7 @@ export interface SessionRemovedParams {
  *     "changes": {
  *       "title": "Refactor auth middleware",
  *       "status": 8,
- *       "modifiedAt": 1710000123456
+ *       "modifiedAt": "2024-03-09T16:02:03.456Z"
  *     }
  *   }
  * }
@@ -127,3 +126,79 @@ export interface SessionSummaryChangedParams {
      */
     changes: Partial<SessionSummary>;
 }
+/**
+ * Generic progress notification for a long-running operation.
+ *
+ * A client opts in to progress for a request by including a `progressToken` in
+ * that request (today: the `progressToken` field on `createSession`). If the
+ * server does long-running work to service the request — e.g. lazily
+ * downloading an agent's native SDK the first time a session of that provider
+ * is materialized — it emits `progress` notifications carrying the same token.
+ *
+ * The notification is operation-agnostic: it says nothing about *what* is
+ * progressing. The client correlates `progressToken` back to the request it
+ * originated from (and thus the UI surface awaiting it) and renders its own
+ * localized indicator. The same channel serves any future long-running
+ * operation without a new method.
+ *
+ * Semantics:
+ *
+ * - `progress` is monotonically non-decreasing for a given `progressToken`.
+ * - `total` is present only when the server knows the magnitude up front
+ *   (e.g. a `Content-Length`); when absent the client SHOULD show an
+ *   indeterminate indicator.
+ * - The operation is complete when `progress === total`. The server MUST emit a
+ *   final frame satisfying `progress === total`; when the total was never
+ *   known, it sets `total` to the final `progress` on that frame. No further
+ *   frames reference the token afterwards.
+ * - The server MAY emit no progress at all (e.g. the work was already done);
+ *   the client then never shows an indicator.
+ * - Like all notifications this is ephemeral and is **not** replayed on
+ *   reconnect. A client that never receives the terminal frame SHOULD expire
+ *   the indicator after an idle timeout.
+ *
+ * @category Protocol Notifications
+ * @method root/progress
+ * @direction Server → Client
+ * @messageType Notification
+ * @version 1
+ * @example
+ * ```json
+ * {
+ *   "jsonrpc": "2.0",
+ *   "method": "root/progress",
+ *   "params": {
+ *     "channel": "ahp-root://",
+ *     "progressToken": "9b2c1f7e-4a0d-4e2b-8b1a-2f7e4a0d4e2b",
+ *     "progress": 18874368,
+ *     "total": 41957498
+ *   }
+ * }
+ * ```
+ */
+export interface ProgressParams {
+    /** Channel URI this notification belongs to (the root channel). */
+    channel: URI;
+    /**
+     * Echoes the `progressToken` the client supplied on the originating request
+     * (e.g. the `progressToken` field of `createSession`), correlating this frame
+     * to that call. Unique across the client's active requests.
+     */
+    progressToken: string;
+    /**
+     * Progress so far, in operation-defined units (e.g. bytes received).
+     * Monotonically non-decreasing for a given `progressToken`.
+     */
+    progress: number;
+    /**
+     * Total when known up front (e.g. from a `Content-Length`); omitted ⇒
+     * indeterminate. The operation is complete once `progress === total`.
+     */
+    total?: number;
+    /**
+     * Optional human-readable progress message. The client owns its own
+     * (localized) presentation derived from the originating request; generic
+     * clients that don't track the token MAY display this instead.
+     */
+    message?: string;
+}

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

@@ -1,4 +1,4 @@
-import type { ConfigSchema, ProtectedResourceMetadata } from "../common/state.js";
+import type { ConfigSchema, JsonPrimitive, ProtectedResourceMetadata } from "../common/state.js";
 import type { TerminalInfo } from "../channels-terminal/state.js";
 import type { Customization } from "../channels-session/state.js";
 /**
@@ -70,6 +70,43 @@ export interface AgentInfo {
      * into the session's `customizations` list.
      */
     customizations?: Customization[];
+    /**
+     * Static capabilities the agent advertises about itself. Clients use these
+     * to gate features (multi-chat, fork) instead of switching on the provider
+     * id.
+     */
+    capabilities?: AgentCapabilities;
+}
+/**
+ * Static capabilities an {@link AgentInfo} advertises. Modelled after MCP
+ * capabilities: each field is opt-in and its presence (an empty object `{}`)
+ * signals support, while absence means the feature is unsupported and the
+ * corresponding client commands MUST NOT be used. Sub-fields carry
+ * per-capability options.
+ *
+ * @category Root State
+ */
+export interface AgentCapabilities {
+    /**
+     * The agent can host more than one concurrent chat per session. When absent,
+     * clients MUST NOT call `createChat` to open chats beyond the default one the
+     * session starts with. An empty object `{}` advertises multi-chat without
+     * forking; set {@link MultipleChatsCapability.fork} to also allow forking.
+     */
+    multipleChats?: MultipleChatsCapability;
+}
+/**
+ * Options for the {@link AgentCapabilities.multipleChats} capability.
+ *
+ * @category Root State
+ */
+export interface MultipleChatsCapability {
+    /**
+     * The agent can fork a chat from a specific turn. When absent or `false`,
+     * clients MUST NOT pass a {@link ChatForkSource} (`source`) to `createChat`.
+     * Forking always implies multi-chat support.
+     */
+    fork?: boolean;
 }
 /**
  * @category Root State
@@ -83,6 +120,10 @@ export interface SessionModelInfo {
     name: string;
     /** Maximum context window size */
     maxContextWindow?: number;
+    /** Maximum number of output tokens the model can generate */
+    maxOutputTokens?: number;
+    /** Maximum number of prompt (input) tokens the model accepts */
+    maxPromptTokens?: number;
     /** Whether the model supports vision */
     supportsVision?: boolean;
     /** Policy configuration state */
@@ -111,8 +152,12 @@ export interface SessionModelInfo {
 export interface ModelSelection {
     /** Model identifier */
     id: string;
-    /** Model-specific configuration values */
-    config?: Record<string, string>;
+    /**
+     * Model-specific configuration values. Values are JSON primitives: most
+     * pickers produce strings, but some (e.g. a numeric context-size picker)
+     * produce numbers or booleans, which are carried through as-is.
+     */
+    config?: Record<string, JsonPrimitive>;
 }
 /**
  * Live agent-host configuration metadata.