@codingame/monaco-vscode-api 28.4.1 → 29.0.0

package/vscode/src/vs/workbench/contrib/chat/common/attachments/chatVariableEntries.js

@@ -67,9 +67,9 @@ var IDiagnosticVariableEntryFilterData;
             }
             return data.problemMessage.substring(0, lastSpace) + "…";
         }
-        let labelStr = ( localize(6979, "All Problems"));
+        let labelStr = ( localize(7190, "All Problems"));
         if (data.filterUri) {
-            labelStr = ( localize(6980, "Problems in {0}", basename(data.filterUri)));
+            labelStr = ( localize(7191, "Problems in {0}", basename(data.filterUri)));
         }
         return labelStr;
     }
@@ -165,8 +165,8 @@ function isStringImplicitContextValue(value) {
 }
 var PromptFileVariableKind;
 (function(PromptFileVariableKind) {
-    PromptFileVariableKind["Instruction"] = "vscode.prompt.instructions.root";
-    PromptFileVariableKind["InstructionReference"] = "vscode.prompt.instructions";
+    PromptFileVariableKind["Instruction"] = "vscode.instructions.file.root";
+    PromptFileVariableKind["InstructionReference"] = "vscode.instructions.file.reference";
     PromptFileVariableKind["PromptFile"] = "vscode.prompt.file";
 })(PromptFileVariableKind || (PromptFileVariableKind = {}));
 function toPromptFileVariableEntry(uri, kind, originLabel, automaticallyAdded = false, toolReferences) {
@@ -182,13 +182,17 @@ function toPromptFileVariableEntry(uri, kind, originLabel, automaticallyAdded =
         automaticallyAdded
     };
 }
+var PromptTextVariableKind;
+(function(PromptTextVariableKind) {
+    PromptTextVariableKind["CustomizationsIndex"] = "vscode.customizations.index";
+})(PromptTextVariableKind || (PromptTextVariableKind = {}));
 function toPromptTextVariableEntry(content, automaticallyAdded = false, toolReferences) {
     return {
-        id: `vscode.prompt.instructions.text`,
-        name: `prompt:instructionsList`,
+        id: PromptTextVariableKind.CustomizationsIndex,
+        name: `prompt:customizationsIndex`,
         value: content,
         kind: "promptText",
-        modelDescription: "Prompt instructions list",
+        modelDescription: "Chat customizations index",
         automaticallyAdded,
         toolReferences
     };

package/vscode/src/vs/workbench/contrib/chat/common/chatDebugService.d.ts

@@ -0,0 +1,215 @@
+import { URI } from "../../../../base/common/uri.js";
+import { CancellationToken } from "../../../../base/common/cancellation.js";
+/**
+ * The severity level of a chat debug log event.
+ */
+export declare enum ChatDebugLogLevel {
+    Trace = 0,
+    Info = 1,
+    Warning = 2,
+    Error = 3
+}
+/**
+ * The result of a hook execution.
+ */
+export declare enum ChatDebugHookResult {
+    /** The hook executed successfully (exit code 0). */
+    Success = 0,
+    /** The hook returned a blocking error (exit code 2). */
+    Error = 1,
+    /** The hook returned a non-blocking warning (other non-zero exit codes). */
+    NonBlockingError = 2
+}
+/**
+ * Common properties shared by all chat debug event types.
+ */
+export interface IChatDebugEventCommon {
+    readonly id?: string;
+    readonly sessionResource: URI;
+    readonly created: Date;
+    readonly parentEventId?: string;
+}
+/**
+ * A tool call event in the chat debug log.
+ */
+export interface IChatDebugToolCallEvent extends IChatDebugEventCommon {
+    readonly kind: "toolCall";
+    readonly toolName: string;
+    readonly toolCallId?: string;
+    readonly input?: string;
+    readonly output?: string;
+    readonly result?: "success" | "error";
+    readonly durationInMillis?: number;
+}
+/**
+ * A model turn event representing an LLM request/response.
+ */
+export interface IChatDebugModelTurnEvent extends IChatDebugEventCommon {
+    readonly kind: "modelTurn";
+    readonly model?: string;
+    readonly requestName?: string;
+    readonly inputTokens?: number;
+    readonly outputTokens?: number;
+    readonly totalTokens?: number;
+    readonly durationInMillis?: number;
+}
+/**
+ * A generic log event for unstructured or miscellaneous messages.
+ */
+export interface IChatDebugGenericEvent extends IChatDebugEventCommon {
+    readonly kind: "generic";
+    readonly name: string;
+    readonly details?: string;
+    readonly level: ChatDebugLogLevel;
+    readonly category?: string;
+}
+/**
+ * A subagent invocation event, representing a spawned sub-agent within a session.
+ */
+export interface IChatDebugSubagentInvocationEvent extends IChatDebugEventCommon {
+    readonly kind: "subagentInvocation";
+    readonly agentName: string;
+    readonly description?: string;
+    readonly status?: "running" | "completed" | "failed";
+    readonly durationInMillis?: number;
+    readonly toolCallCount?: number;
+    readonly modelTurnCount?: number;
+}
+/**
+ * A named section within a user message or agent response.
+ */
+export interface IChatDebugMessageSection {
+    readonly name: string;
+    readonly content: string;
+}
+/**
+ * A user message event, representing the full prompt sent by the user.
+ */
+export interface IChatDebugUserMessageEvent extends IChatDebugEventCommon {
+    readonly kind: "userMessage";
+    readonly message: string;
+    readonly sections: readonly IChatDebugMessageSection[];
+}
+/**
+ * An agent response event, representing the agent's response.
+ */
+export interface IChatDebugAgentResponseEvent extends IChatDebugEventCommon {
+    readonly kind: "agentResponse";
+    readonly message: string;
+    readonly sections: readonly IChatDebugMessageSection[];
+}
+/**
+ * Union of all internal chat debug event types.
+ */
+export type IChatDebugEvent = IChatDebugToolCallEvent | IChatDebugModelTurnEvent | IChatDebugGenericEvent | IChatDebugSubagentInvocationEvent | IChatDebugUserMessageEvent | IChatDebugAgentResponseEvent;
+/**
+ * Plain text content for a resolved debug event.
+ */
+export interface IChatDebugEventTextContent {
+    readonly kind: "text";
+    readonly value: string;
+}
+/**
+ * The status of a file in a file list content.
+ */
+export type ChatDebugFileStatus = "loaded" | "skipped";
+/**
+ * A single file entry in a file list content.
+ */
+export interface IChatDebugFileEntry {
+    readonly uri: URI;
+    readonly name?: string;
+    readonly status: ChatDebugFileStatus;
+    readonly storage?: string;
+    readonly extensionId?: string;
+    readonly skipReason?: string;
+    readonly errorMessage?: string;
+    readonly duplicateOf?: URI;
+}
+/**
+ * A source folder entry in a file list content.
+ */
+export interface IChatDebugSourceFolderEntry {
+    readonly uri: URI;
+    readonly storage: string;
+}
+/**
+ * Structured file list content for a resolved debug event.
+ * Contains resolved files and skipped/failed paths for rich rendering.
+ */
+export interface IChatDebugEventFileListContent {
+    readonly kind: "fileList";
+    readonly discoveryType: string;
+    readonly files: readonly IChatDebugFileEntry[];
+    readonly sourceFolders?: readonly IChatDebugSourceFolderEntry[];
+}
+/**
+ * Structured message content for a resolved debug event,
+ * containing collapsible sections.
+ */
+export interface IChatDebugEventMessageContent {
+    readonly kind: "message";
+    readonly type: "user" | "agent";
+    readonly message: string;
+    readonly sections: readonly IChatDebugMessageSection[];
+}
+/**
+ * Structured tool call content for a resolved debug event.
+ * Contains the tool name, status, arguments, and output for rich rendering.
+ */
+export interface IChatDebugEventToolCallContent {
+    readonly kind: "toolCall";
+    readonly toolName: string;
+    readonly result?: "success" | "error";
+    readonly durationInMillis?: number;
+    readonly input?: string;
+    readonly output?: string;
+}
+/**
+ * Structured model turn content for a resolved debug event.
+ * Contains request metadata, token usage, and timing for rich rendering.
+ */
+export interface IChatDebugEventModelTurnContent {
+    readonly kind: "modelTurn";
+    readonly requestName: string;
+    readonly model?: string;
+    readonly status?: string;
+    readonly durationInMillis?: number;
+    readonly timeToFirstTokenInMillis?: number;
+    readonly maxInputTokens?: number;
+    readonly maxOutputTokens?: number;
+    readonly inputTokens?: number;
+    readonly outputTokens?: number;
+    readonly cachedTokens?: number;
+    readonly totalTokens?: number;
+    readonly errorMessage?: string;
+    readonly sections?: readonly IChatDebugMessageSection[];
+}
+/**
+ * Structured hook execution content for a resolved debug event.
+ * Contains the hook type, command, input, output, and result for rich rendering.
+ */
+export interface IChatDebugEventHookContent {
+    readonly kind: "hook";
+    readonly hookType: string;
+    readonly command?: string;
+    readonly result?: ChatDebugHookResult;
+    readonly durationInMillis?: number;
+    readonly input?: string;
+    readonly output?: string;
+    readonly exitCode?: number;
+    readonly errorMessage?: string;
+}
+/**
+ * Union of all resolved event content types.
+ */
+export type IChatDebugResolvedEventContent = IChatDebugEventTextContent | IChatDebugEventFileListContent | IChatDebugEventMessageContent | IChatDebugEventToolCallContent | IChatDebugEventModelTurnContent | IChatDebugEventHookContent;
+/**
+ * Provider interface for debug events.
+ */
+export interface IChatDebugLogProvider {
+    provideChatDebugLog(sessionResource: URI, token: CancellationToken): Promise<IChatDebugEvent[] | undefined>;
+    resolveChatDebugLogEvent?(eventId: string, token: CancellationToken): Promise<IChatDebugResolvedEventContent | undefined>;
+    provideChatDebugLogExport?(sessionResource: URI, token: CancellationToken): Promise<Uint8Array | undefined>;
+    resolveChatDebugLogImport?(data: Uint8Array, token: CancellationToken): Promise<URI | undefined>;
+}

package/vscode/src/vs/workbench/contrib/chat/common/chatDebugService.js

@@ -0,0 +1,17 @@
+
+
+var ChatDebugLogLevel;
+(function (ChatDebugLogLevel) {
+    ChatDebugLogLevel[ChatDebugLogLevel["Trace"] = 0] = "Trace";
+    ChatDebugLogLevel[ChatDebugLogLevel["Info"] = 1] = "Info";
+    ChatDebugLogLevel[ChatDebugLogLevel["Warning"] = 2] = "Warning";
+    ChatDebugLogLevel[ChatDebugLogLevel["Error"] = 3] = "Error";
+})(ChatDebugLogLevel || (ChatDebugLogLevel = {}));
+var ChatDebugHookResult;
+(function (ChatDebugHookResult) {
+    ChatDebugHookResult[ChatDebugHookResult["Success"] = 0] = "Success";
+    ChatDebugHookResult[ChatDebugHookResult["Error"] = 1] = "Error";
+    ChatDebugHookResult[ChatDebugHookResult["NonBlockingError"] = 2] = "NonBlockingError";
+})(ChatDebugHookResult || (ChatDebugHookResult = {}));
+
+export { ChatDebugHookResult, ChatDebugLogLevel };

package/vscode/src/vs/workbench/contrib/chat/common/chatDebugService.service.d.ts

@@ -1,7 +1,7 @@
 import { Event } from "../../../../base/common/event.js";
 import { IDisposable } from "../../../../base/common/lifecycle.js";
 import { URI } from "../../../../base/common/uri.js";
-import { IChatDebugEvent, ChatDebugLogLevel, IChatDebugLogProvider, IChatDebugResolvedEventContent } from "@codingame/monaco-vscode-chat-service-override/vscode/vs/workbench/contrib/chat/common/chatDebugService";
+import { IChatDebugEvent, ChatDebugLogLevel, IChatDebugLogProvider, IChatDebugResolvedEventContent } from "./chatDebugService.js";
 export declare const IChatDebugService: import("../../../../platform/instantiation/common/instantiation.js").ServiceIdentifier<IChatDebugService>;
 /**
 * Service for collecting and exposing chat debug events.
@@ -77,6 +77,29 @@ export interface IChatDebugService extends IDisposable {
     */
     resolveEvent(eventId: string): Promise<IChatDebugResolvedEventContent | undefined>;
     /**
+    /**
+    * Export the debug log for a session via the registered provider.
+    */
+    exportLog(sessionResource: URI): Promise<Uint8Array | undefined>;
+    /**
+    * Import a previously exported debug log via the registered provider.
+    * Returns the session URI for the imported data.
+    */
+    importLog(data: Uint8Array): Promise<URI | undefined>;
+    /**
+    * Returns true if the event was logged by VS Code core
+    * (not sourced from an external provider).
+    */
+    isCoreEvent(event: IChatDebugEvent): boolean;
+    /**
+    * Store a human-readable title for an imported session.
+    */
+    setImportedSessionTitle(sessionResource: URI, title: string): void;
+    /**
+    * Get the stored title for an imported session, if available.
+    */
+    getImportedSessionTitle(sessionResource: URI): string | undefined;
+    /**
     * Fired when debug data is attached to a session.
     */
     readonly onDidAttachDebugData: Event<URI>;

package/vscode/src/vs/workbench/contrib/chat/common/chatModes.d.ts

@@ -131,7 +131,7 @@ type IChatModeSourceData = {
     readonly extensionId: string;
     type?: ExtensionAgentSourceType;
 } | {
-    readonly storage: PromptsStorage.local | PromptsStorage.user;
+    readonly storage: PromptsStorage.local | PromptsStorage.user | PromptsStorage.internal;
 } | {
     readonly storage: PromptsStorage.plugin;
     readonly pluginUri: URI;
@@ -162,4 +162,53 @@ export declare function isBuiltinChatMode(mode: IChatMode): boolean;
  * to avoid leaking PII; builtin and extension mode names are returned as-is.
  */
 export declare function getModeNameForTelemetry(mode: IChatMode): string;
+/**
+ * Generates a stable identifier for a handoff by combining the target agent
+ * name with a slugified version of the display label.
+ *
+ * Within a single source agent, the combination of `agent` + `label` must be
+ * unique for IDs to be unambiguous.
+ *
+ * @example
+ * ```
+ * getHandoffId({ agent: 'agent', label: 'Continue', prompt: '...' })
+ * // => 'agent:continue'
+ * ```
+ */
+export declare function getHandoffId(handoff: IHandOff): string;
+/**
+ * Describes a single handoff defined in a custom agent's `.agent.md` file.
+ */
+export interface IHandoffInfo {
+    /** Stable identifier for programmatic matching (format: `<agent>:<slugified-label>`). */
+    readonly id: string;
+    readonly label: string;
+    readonly agent: string;
+    readonly prompt: string;
+    readonly send?: boolean;
+    readonly showContinueOn?: boolean;
+    readonly model?: string;
+}
+/**
+ * Describes a custom agent (or built-in mode) and the handoffs it defines.
+ */
+export interface ICustomAgentInfo {
+    readonly id: string;
+    readonly name: string;
+    readonly isBuiltin: boolean;
+    readonly visibility: {
+        readonly userInvocable: boolean;
+        readonly agentInvocable: boolean;
+    };
+    readonly handoffs: IHandoffInfo[];
+}
+/**
+ * Builds an array of {@link ICustomAgentInfo} with handoff metadata for the given agents/modes.
+ *
+ * @param modes - The set of agents/modes to include. Pass all modes to get a
+ *   complete picture, or a filtered subset to scope the result.
+ * @returns One entry per agent/mode, each containing the agent's metadata and
+ *   its declared handoffs.
+ */
+export declare function buildCustomAgentHandoffsInfo(modes: readonly IChatMode[]): ICustomAgentInfo[];
 export {};

package/vscode/src/vs/workbench/contrib/chat/common/chatModes.js

@@ -320,7 +320,7 @@ function isChatModeSourceData(value) {
     if (data.storage === PromptsStorage.plugin) {
         return isUriComponents(data.pluginUri);
     }
-    return data.storage === PromptsStorage.local || data.storage === PromptsStorage.user;
+    return data.storage === PromptsStorage.local || data.storage === PromptsStorage.user || data.storage === PromptsStorage.internal;
 }
 function serializeChatModeSource(source) {
     if (!source) {
@@ -360,6 +360,11 @@ function reviveChatModeSource(data) {
             pluginUri: URI.revive(data.pluginUri)
         };
     }
+    if (data.storage === PromptsStorage.internal) {
+        return {
+            storage: PromptsStorage.internal
+        };
+    }
     return {
         storage: data.storage
     };
@@ -390,9 +395,9 @@ class BuiltinChatMode {
 }
 var ChatMode;
 (function(ChatMode) {
-    ChatMode.Ask = ( new BuiltinChatMode(ChatModeKind.Ask, "Ask", ( localize(6981, "Explore and understand your code")), Codicon.question));
-    ChatMode.Edit = ( new BuiltinChatMode(ChatModeKind.Edit, "Edit", ( localize(6982, "Edit or refactor selected code")), Codicon.edit));
-    ChatMode.Agent = ( new BuiltinChatMode(ChatModeKind.Agent, "Agent", ( localize(6983, "Describe what to build")), Codicon.agent));
+    ChatMode.Ask = ( new BuiltinChatMode(ChatModeKind.Ask, "Ask", ( localize(7197, "Explore and understand your code")), Codicon.question));
+    ChatMode.Edit = ( new BuiltinChatMode(ChatModeKind.Edit, "Edit", ( localize(7198, "Edit or refactor selected code")), Codicon.edit));
+    ChatMode.Agent = ( new BuiltinChatMode(ChatModeKind.Agent, "Agent", ( localize(7199, "Describe what to build")), Codicon.agent));
 })(ChatMode || (ChatMode = {}));
 function isBuiltinChatMode(mode) {
     return mode.id === ChatMode.Ask.id || mode.id === ChatMode.Edit.id || mode.id === ChatMode.Agent.id;
@@ -404,5 +409,39 @@ function getModeNameForTelemetry(mode) {
     }
     return mode.name.get();
 }
+function getHandoffId(handoff) {
+    const slug = handoff.label.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+    return `${handoff.agent}:${slug}`;
+}
+function buildCustomAgentHandoffsInfo(modes) {
+    return ( modes.map(mode => {
+        const handoffs = mode.handOffs?.get() ?? [];
+        const visibility = mode.visibility?.get();
+        return {
+            id: mode.id,
+            name: mode.name.get(),
+            isBuiltin: mode.isBuiltin,
+            visibility: {
+                userInvocable: visibility?.userInvocable ?? true,
+                agentInvocable: visibility?.agentInvocable ?? true
+            },
+            handoffs: ( handoffs.map(h => ({
+                id: getHandoffId(h),
+                label: h.label,
+                agent: h.agent,
+                prompt: h.prompt,
+                ...(h.send !== undefined ? {
+                    send: h.send
+                } : {}),
+                ...(h.showContinueOn !== undefined ? {
+                    showContinueOn: h.showContinueOn
+                } : {}),
+                ...(h.model !== undefined ? {
+                    model: h.model
+                } : {})
+            })))
+        };
+    }));
+}
 
-export { BuiltinChatMode, ChatMode, ChatModeService, CustomChatMode, getModeNameForTelemetry, isBuiltinChatMode };
+export { BuiltinChatMode, ChatMode, ChatModeService, CustomChatMode, buildCustomAgentHandoffsInfo, getHandoffId, getModeNameForTelemetry, isBuiltinChatMode };