@codingame/monaco-vscode-chat-service-override 31.0.1 → 32.0.1

package/vscode/src/vs/platform/agentHost/common/agentService.d.ts

@@ -4,11 +4,11 @@ import type { IObservable } from "@codingame/monaco-vscode-api/vscode/vs/base/co
 import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
 import type { ISyncedCustomization } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentPluginManager";
 import type { IAgentSubscription } from "./state/agentSubscription.js";
-import type { ICreateTerminalParams, IResolveSessionConfigResult, ISessionConfigCompletionsResult } from "./state/protocol/commands.js";
-import { IProtectedResourceMetadata, type IConfigSchema, type IFileEdit, type IModelSelection, type IToolDefinition } from "@codingame/monaco-vscode-xterm-common/vscode/vs/platform/agentHost/common/state/protocol/state";
-import type { IActionEnvelope, INotification, ISessionAction, ITerminalAction } from "./state/sessionActions.js";
-import type { IResourceCopyParams, IResourceCopyResult, IResourceDeleteParams, IResourceDeleteResult, IResourceListResult, IResourceMoveParams, IResourceMoveResult, IResourceReadResult, IResourceWriteParams, IResourceWriteResult } from "./state/sessionProtocol.js";
-import { AttachmentType, ComponentToState, SessionInputResponseKind, SessionStatus, StateComponents, type ICustomizationRef, type IPendingMessage, type IRootState, type ISessionInputAnswer, type ISessionInputRequest, type IToolCallResult, type IToolResultContent, type PolicyState, type StringOrMarkdown } from "@codingame/monaco-vscode-xterm-common/vscode/vs/platform/agentHost/common/state/sessionState";
+import type { CompletionsParams, CompletionsResult, CreateTerminalParams, ResolveSessionConfigResult, SessionConfigCompletionsResult } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/commands";
+import { ProtectedResourceMetadata, type ConfigSchema, type FileEdit, type MessageAttachment, type ModelSelection, type SessionActiveClient, type ToolCallPendingConfirmationState, type ToolDefinition } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/state";
+import type { ActionEnvelope, INotification, IRootConfigChangedAction, SessionAction, TerminalAction } from "./state/sessionActions.js";
+import type { ResourceCopyParams, ResourceCopyResult, ResourceDeleteParams, ResourceDeleteResult, ResourceListResult, ResourceMoveParams, ResourceMoveResult, ResourceReadResult, ResourceWriteParams, ResourceWriteResult } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionProtocol";
+import { ComponentToState, SessionInputResponseKind, SessionStatus, StateComponents, type CustomizationRef, type PendingMessage, type RootState, type SessionCustomization, type SessionInputAnswer, type SessionMeta, type ToolCallResult, type Turn, type PolicyState } from "@codingame/monaco-vscode-xterm-common/vscode/vs/platform/agentHost/common/state/sessionState";
 export declare enum AgentHostIpcChannels {
     /** Channel for the agent host service on the main-process side */
     AgentHost = "agentHost",
@@ -21,10 +21,39 @@ export declare enum AgentHostIpcChannels {
 export declare const AgentHostEnabledSettingId = "chat.agentHost.enabled";
 /** Configuration key that controls whether per-host IPC traffic output channels are created. */
 export declare const AgentHostIpcLoggingSettingId = "chat.agentHost.ipcLoggingEnabled";
+/** Configuration key that controls whether AHP JSONL logs are written for agent host transports. */
+export declare const AgentHostAhpJsonlLoggingSettingId = "chat.agentHost.ahpJsonlLoggingEnabled";
+/**
+ * Configuration key that holds the absolute path to a locally-installed
+ * `@anthropic-ai/claude-agent-sdk` package. When non-empty, the Claude agent
+ * provider is registered inside the agent host and the SDK module is loaded
+ * via dynamic `import()` from this path. When empty (the default), the
+ * Claude provider is not registered. The SDK is intentionally not bundled
+ * with VS Code; users opting into the Claude agent install the SDK
+ * themselves and point this setting at it. The agent host process must be
+ * restarted for changes to take effect.
+ */
+export declare const AgentHostClaudeAgentSdkPathSettingId = "chat.agentHost.claudeAgent.path";
+/**
+ * Environment variable that holds the absolute path to a locally-installed
+ * `@anthropic-ai/claude-agent-sdk` package. When set to a non-empty value,
+ * the agent host process registers the Claude agent provider and loads the
+ * SDK module from this path. Set by the agent host starters from
+ * {@link AgentHostClaudeAgentSdkPathSettingId}, and may also be set directly
+ * by developers as an override.
+ */
+export declare const AgentHostClaudeSdkPathEnvVar = "VSCODE_AGENT_HOST_CLAUDE_SDK_PATH";
 /** Result of starting the agent host WebSocket server on-demand. */
 export interface IAgentHostSocketInfo {
     readonly socketPath: string;
 }
+/** Inspector listener information for the agent host process. */
+export interface IAgentHostInspectInfo {
+    readonly host: string;
+    readonly port: number;
+    /** A `devtools://` URL that can be opened with `INativeHostService.openDevToolsWindow`. */
+    readonly devtoolsUrl: string;
+}
 /**
  * IPC service exposed on the {@link AgentHostIpcChannels.ConnectionTracker}
  * channel. Used by the server process for lifetime management and by the
@@ -38,6 +67,13 @@ export interface IConnectionTrackerService {
      * If a server is already running, returns the existing info.
      */
     startWebSocketServer(): Promise<IAgentHostSocketInfo>;
+    /**
+     * Get inspector listener info for the agent host process. If the inspector
+     * is not currently active and `tryEnable` is true, opens the inspector on
+     * a random local port. Returns `undefined` if the inspector cannot be
+     * enabled (e.g. running in an environment without `node:inspector`).
+     */
+    getInspectInfo(tryEnable: boolean): Promise<IAgentHostInspectInfo | undefined>;
 }
 export interface IAgentSessionMetadata {
     readonly session: URI;
@@ -46,11 +82,22 @@ export interface IAgentSessionMetadata {
     readonly project?: IAgentSessionProjectInfo;
     readonly summary?: string;
     readonly status?: SessionStatus;
-    readonly model?: IModelSelection;
+    /** Human-readable description of what the session is currently doing. */
+    readonly activity?: string;
+    readonly model?: ModelSelection;
     readonly workingDirectory?: URI;
+    readonly customizationDirectory?: URI;
     readonly isRead?: boolean;
-    readonly isDone?: boolean;
-    readonly diffs?: readonly IFileEdit[];
+    readonly isArchived?: boolean;
+    readonly diffs?: readonly FileEdit[];
+    /**
+     * Side-channel metadata mirroring {@link SessionState._meta}, propagated
+     * to clients via per-session state subscriptions.
+     * Producers SHOULD use namespaced keys; consumers MUST ignore unknown
+     * keys. Use the typed accessors in `sessionState.ts` (e.g.
+     * `readSessionGitState`) for well-known slots.
+     */
+    readonly _meta?: SessionMeta;
 }
 export interface IAgentSessionProjectInfo {
     readonly uri: URI;
@@ -61,6 +108,26 @@ export interface IAgentCreateSessionResult {
     readonly project?: IAgentSessionProjectInfo;
     /** The resolved working directory, which may differ from the requested one (e.g. worktree). */
     readonly workingDirectory?: URI;
+    /**
+     * `true` when the agent only allocated an in-memory placeholder for this
+     * session (no SDK session, no worktree, no on-disk state). Materialization
+     * happens lazily on the first {@link IAgent.sendMessage}, at which point
+     * the agent fires {@link IAgent.onDidMaterializeSession}. The
+     * {@link IAgentService} uses this flag to defer the `sessionAdded` protocol
+     * notification so observers don't see the session in their list until it
+     * has been persisted.
+     */
+    readonly provisional?: boolean;
+}
+/**
+ * Payload of {@link IAgent.onDidMaterializeSession}. Fired once per session
+ * when a previously {@link IAgentCreateSessionResult.provisional} session has
+ * its SDK session, worktree (if any), and on-disk metadata in place.
+ */
+export interface IAgentMaterializeSessionEvent {
+    readonly session: URI;
+    readonly workingDirectory: URI | undefined;
+    readonly project: IAgentSessionProjectInfo | undefined;
 }
 export type AgentProvider = string;
 /** Metadata describing an agent backend, discovered over IPC. */
@@ -73,7 +140,7 @@ export interface IAgentDescriptor {
  * Parameters for the `authenticate` command.
  * Analogous to sending `Authorization: Bearer <token>` (RFC 6750 section 2.1).
  */
-export interface IAuthenticateParams {
+export interface AuthenticateParams {
     /**
      * The `resource` identifier from the server's
      * {@link IAuthorizationProtectedResourceMetadata} that this token targets.
@@ -85,16 +152,33 @@ export interface IAuthenticateParams {
 /**
  * Result of the `authenticate` command.
  */
-export interface IAuthenticateResult {
+export interface AuthenticateResult {
     /** Whether the token was accepted. */
     readonly authenticated: boolean;
 }
+/**
+ * Canonical {@link ProtectedResourceMetadata} for the GitHub Copilot
+ * resource. Shared between every agent provider that consumes a GitHub
+ * Copilot bearer token (e.g. Copilot CLI, Claude) so they advertise an
+ * identical resource identifier to the auth flow — clients dispatch by
+ * `resource`, and divergent metadata would silently route the same
+ * token down separate code paths.
+ */
+export declare const GITHUB_COPILOT_PROTECTED_RESOURCE: ProtectedResourceMetadata;
 export interface IAgentCreateSessionConfig {
     readonly provider?: AgentProvider;
-    readonly model?: IModelSelection;
+    readonly model?: ModelSelection;
     readonly session?: URI;
     readonly workingDirectory?: URI;
-    readonly config?: Record<string, string>;
+    readonly config?: Record<string, unknown>;
+    /**
+     * Eagerly claim the active client role for the new session. When provided,
+     * the server initializes the session with this client as the active
+     * client, equivalent to dispatching a `session/activeClientChanged`
+     * action immediately after creation. The `clientId` MUST match the
+     * connection's own `clientId`.
+     */
+    readonly activeClient?: SessionActiveClient;
     /** Fork from an existing session at a specific turn. */
     readonly fork?: {
         readonly session: URI;
@@ -109,199 +193,107 @@ export interface IAgentCreateSessionConfig {
         readonly turnIdMapping?: ReadonlyMap<string, string>;
     };
 }
-export declare const AgentHostSessionConfigBranchNameHintKey = "branchNameHint";
 export interface IAgentResolveSessionConfigParams {
     readonly provider?: AgentProvider;
     readonly workingDirectory?: URI;
-    readonly config?: Record<string, string>;
+    readonly config?: Record<string, unknown>;
 }
 export interface IAgentSessionConfigCompletionsParams extends IAgentResolveSessionConfigParams {
     readonly property: string;
     readonly query?: string;
 }
-/** Serializable attachment passed alongside a message to the agent host. */
-export interface IAgentAttachment {
-    readonly type: AttachmentType;
-    readonly path: string;
-    readonly displayName?: string;
-    /** For selections: the selected text. */
-    readonly text?: string;
-    /** For selections: line/character range. */
-    readonly selection?: {
-        readonly start: {
-            readonly line: number;
-            readonly character: number;
-        };
-        readonly end: {
-            readonly line: number;
-            readonly character: number;
-        };
-    };
-}
 /** Serializable model information from the agent host. */
 export interface IAgentModelInfo {
     readonly provider: AgentProvider;
     readonly id: string;
     readonly name: string;
-    readonly maxContextWindow: number;
+    readonly maxContextWindow?: number;
     readonly supportsVision: boolean;
-    readonly configSchema?: IConfigSchema;
+    readonly configSchema?: ConfigSchema;
     readonly policyState?: PolicyState;
+    readonly _meta?: Record<string, unknown>;
 }
-interface IAgentProgressEventBase {
+/**
+ * A signal emitted by an agent during session execution.
+ *
+ * Most signals carry a protocol {@link SessionAction} directly via the
+ * `kind: 'action'` shape, eliminating a parallel event ontology. A small
+ * number of cases that have no clean protocol action (permission
+ * auto-approval, subagent session creation, steering message
+ * acknowledgment) remain as discriminated non-action signals so the host
+ * can perform side effects before — or instead of — dispatching an action.
+ */
+export type AgentSignal = IAgentActionSignal | IAgentToolPendingConfirmationSignal | IAgentSubagentStartedSignal | IAgentSteeringConsumedSignal;
+/**
+ * Carries a protocol {@link SessionAction} produced by an agent. The host
+ * dispatches the action through the state manager after routing via
+ * {@link IAgentActionSignal.parentToolCallId} (if set).
+ *
+ * Agents are responsible for populating `session` and any `turnId` /
+ * `partId` fields on the action.
+ */
+export interface IAgentActionSignal {
+    readonly kind: "action";
+    /** Top-level session URI. For inner subagent events this is the parent session — see {@link parentToolCallId}. */
     readonly session: URI;
-}
-/** Streaming text delta from the assistant (`assistant.message_delta`). */
-export interface IAgentDeltaEvent extends IAgentProgressEventBase {
-    readonly type: "delta";
-    readonly messageId: string;
-    readonly content: string;
-    readonly parentToolCallId?: string;
-}
-/** A complete assistant message (`assistant.message`), used for history reconstruction. */
-export interface IAgentMessageEvent extends IAgentProgressEventBase {
-    readonly type: "message";
-    readonly role: "user" | "assistant";
-    readonly messageId: string;
-    readonly content: string;
-    readonly toolRequests?: readonly {
-        readonly toolCallId: string;
-        readonly name: string;
-        /** Serialized JSON of arguments, if available. */
-        readonly arguments?: string;
-        readonly type?: "function" | "custom";
-    }[];
-    readonly reasoningOpaque?: string;
-    readonly reasoningText?: string;
-    readonly encryptedContent?: string;
+    /** Protocol action to dispatch. */
+    readonly action: SessionAction;
+    /** If set, route the action to the subagent session belonging to this tool call. */
     readonly parentToolCallId?: string;
 }
-/** The session has finished processing and is waiting for input (`session.idle`). */
-export interface IAgentIdleEvent extends IAgentProgressEventBase {
-    readonly type: "idle";
-}
-/** A tool has started executing (`tool.execution_start`). */
-export interface IAgentToolStartEvent extends IAgentProgressEventBase {
-    readonly type: "tool_start";
-    readonly toolCallId: string;
-    readonly toolName: string;
-    /** Human-readable display name for this tool. */
-    readonly displayName: string;
-    /** Message describing the tool invocation in progress (e.g., "Running `echo hello`"). */
-    readonly invocationMessage: StringOrMarkdown;
-    /** A representative input string for display in the UI (e.g., the shell command). */
-    readonly toolInput?: string;
-    /** Hint for the renderer about how to display this tool (e.g., 'terminal' for shell commands, 'subagent' for subagent-spawning tools). */
-    readonly toolKind?: "terminal" | "subagent";
-    /** Language identifier for syntax highlighting (e.g., 'shellscript', 'powershell'). Used with toolKind 'terminal'. */
-    readonly language?: string;
-    /** Serialized JSON of the tool arguments, if available. */
-    readonly toolArguments?: string;
-    /**
-     * For `toolKind === 'subagent'`, the internal name of the agent being
-     * spawned (e.g. 'explore'). Adapters are responsible for extracting this
-     * from their SDK-specific tool argument shape.
-     */
-    readonly subagentAgentName?: string;
-    /**
-     * For `toolKind === 'subagent'`, a human-readable description of the
-     * subagent's task. Adapters are responsible for extracting this from
-     * their SDK-specific tool argument shape.
-     */
-    readonly subagentDescription?: string;
-    readonly mcpServerName?: string;
-    readonly mcpToolName?: string;
-    readonly parentToolCallId?: string;
+/**
+ * A tool has finished collecting parameters and needs the host to decide
+ * whether it should run (or, mid-execution, re-confirm). The host applies
+ * auto-approval logic over {@link permissionKind} / {@link permissionPath}
+ * (see `SessionPermissionManager.getAutoApproval`) and then dispatches the
+ * appropriate `SessionToolCallReady` action — with confirmation options
+ * baked in when the user must approve, or with `confirmed: NotNeeded` when
+ * the host auto-approved.
+ *
+ * Kept as a non-action signal because the host owns this approval policy;
+ * the agent only describes the tool call and the kind of permission being
+ * requested. The {@link state} field carries the protocol-shaped tool-call
+ * state and is dispatched verbatim into the action.
+ */
+export interface IAgentToolPendingConfirmationSignal {
+    readonly kind: "pending_confirmation";
+    readonly session: URI;
+    /** Protocol-shaped pending-confirmation state, dispatched verbatim into `SessionToolCallReady`. */
+    readonly state: ToolCallPendingConfirmationState;
+    /** Host-only auto-approval kind (not part of the dispatched action). */
+    readonly permissionKind?: "shell" | "write" | "mcp" | "read" | "url" | "custom-tool" | "hook" | "memory";
+    /** Host-only auto-approval path target (not part of the dispatched action). */
+    readonly permissionPath?: string;
     /**
-     * If set, this tool is provided by a client and the identified client
-     * is responsible for executing it. Maps to `toolClientId` in the
-     * protocol `session/toolCallStart` action.
+     * If set, the tool call belongs to the subagent rooted at this
+     * parent tool call. Used by the host to route the resulting
+     * `SessionToolCallReady` to the subagent session — otherwise the
+     * action would land on the parent session, where there is no
+     * matching `SessionToolCallStart`.
      */
-    readonly toolClientId?: string;
-}
-/** A tool has finished executing (`tool.execution_complete`). */
-export interface IAgentToolCompleteEvent extends IAgentProgressEventBase {
-    readonly type: "tool_complete";
-    readonly toolCallId: string;
-    /** Tool execution result, matching the protocol {@link IToolCallResult} shape. */
-    readonly result: IToolCallResult;
-    readonly isUserRequested?: boolean;
-    /** Serialized JSON of tool-specific telemetry data. */
-    readonly toolTelemetry?: string;
     readonly parentToolCallId?: string;
 }
-/** The session title has been updated. */
-export interface IAgentTitleChangedEvent extends IAgentProgressEventBase {
-    readonly type: "title_changed";
-    readonly title: string;
-}
-/** An error occurred during session processing. */
-export interface IAgentErrorEvent extends IAgentProgressEventBase {
-    readonly type: "error";
-    readonly errorType: string;
-    readonly message: string;
-    readonly stack?: string;
-}
-/** Token usage information for a request. */
-export interface IAgentUsageEvent extends IAgentProgressEventBase {
-    readonly type: "usage";
-    readonly inputTokens?: number;
-    readonly outputTokens?: number;
-    readonly model?: string;
-    readonly cacheReadTokens?: number;
-}
 /**
- * A running tool requires re-confirmation (e.g. a mid-execution permission check).
- * Maps to `SessionToolCallReady` without `confirmed` to transition Running → PendingConfirmation.
+ * A subagent was spawned by a tool call. The host creates a child session
+ * silently and routes subsequent inner-tool events to it.
+ *
+ * Kept as a non-action signal because subagent session creation has no
+ * protocol action — it's a host-side composition primitive.
  */
-export interface IAgentToolReadyEvent extends IAgentProgressEventBase {
-    readonly type: "tool_ready";
-    readonly toolCallId: string;
-    /** Message describing what confirmation is needed. */
-    readonly invocationMessage: StringOrMarkdown;
-    /** Raw tool input to display. */
-    readonly toolInput?: string;
-    /** Short title for the confirmation prompt. */
-    readonly confirmationTitle?: StringOrMarkdown;
-    /** Kind of permission being requested. */
-    readonly permissionKind?: "shell" | "write" | "mcp" | "read" | "url" | "custom-tool";
-    /** File path associated with the permission request. */
-    readonly permissionPath?: string;
-    /** File edits this tool call will perform, for preview before confirmation. */
-    readonly edits?: {
-        items: IFileEdit[];
-    };
-}
-/** Streaming reasoning/thinking content from the assistant. */
-export interface IAgentReasoningEvent extends IAgentProgressEventBase {
-    readonly type: "reasoning";
-    readonly content: string;
-}
-/** A steering message was consumed (sent to the model). */
-export interface IAgentSteeringConsumedEvent extends IAgentProgressEventBase {
-    readonly type: "steering_consumed";
-    readonly id: string;
-}
-/** The agent's ask_user tool is requesting user input. */
-export interface IAgentUserInputRequestEvent extends IAgentProgressEventBase {
-    readonly type: "user_input_request";
-    readonly request: ISessionInputRequest;
-}
-/** A subagent has been spawned by a tool call. */
-export interface IAgentSubagentStartedEvent extends IAgentProgressEventBase {
-    readonly type: "subagent_started";
+export interface IAgentSubagentStartedSignal {
+    readonly kind: "subagent_started";
+    readonly session: URI;
     readonly toolCallId: string;
     readonly agentName: string;
     readonly agentDisplayName: string;
     readonly agentDescription?: string;
 }
-/** Partial content update for a running tool call (e.g. terminal URI available). */
-export interface IAgentToolContentChangedEvent extends IAgentProgressEventBase {
-    readonly type: "tool_content_changed";
-    readonly toolCallId: string;
-    readonly content: IToolResultContent[];
+/** A steering message was consumed (sent to the model). */
+export interface IAgentSteeringConsumedSignal {
+    readonly kind: "steering_consumed";
+    readonly session: URI;
+    readonly id: string;
 }
-export type IAgentProgressEvent = IAgentDeltaEvent | IAgentMessageEvent | IAgentIdleEvent | IAgentToolStartEvent | IAgentToolReadyEvent | IAgentToolCompleteEvent | IAgentTitleChangedEvent | IAgentErrorEvent | IAgentUsageEvent | IAgentReasoningEvent | IAgentSteeringConsumedEvent | IAgentUserInputRequestEvent | IAgentSubagentStartedEvent | IAgentToolContentChangedEvent;
 export declare namespace AgentSession {
     /**
      * Creates a session URI from a provider name and raw session ID.
@@ -328,15 +320,24 @@ export interface IAgent {
     /** Unique identifier for this provider (e.g. `'copilot'`). */
     readonly id: AgentProvider;
     /** Fires when the provider streams progress for a session. */
-    readonly onDidSessionProgress: Event<IAgentProgressEvent>;
+    readonly onDidSessionProgress: Event<AgentSignal>;
+    /**
+     * Fires once when a previously
+     * {@link IAgentCreateSessionResult.provisional} session has been
+     * materialized — i.e. its SDK session, worktree (if any), and on-disk
+     * metadata are all in place. The {@link IAgentService} uses this event
+     * to fire the deferred `sessionAdded` notification with the now-final
+     * summary.
+     */
+    readonly onDidMaterializeSession?: Event<IAgentMaterializeSessionEvent>;
     /** Create a new session. Returns server-owned session metadata. */
     createSession(config?: IAgentCreateSessionConfig): Promise<IAgentCreateSessionResult>;
     /** Resolve the dynamic configuration schema for creating a session. */
-    resolveSessionConfig(params: IAgentResolveSessionConfigParams): Promise<IResolveSessionConfigResult>;
+    resolveSessionConfig(params: IAgentResolveSessionConfigParams): Promise<ResolveSessionConfigResult>;
     /** Return dynamic completions for a session configuration property. */
-    sessionConfigCompletions(params: IAgentSessionConfigCompletionsParams): Promise<ISessionConfigCompletionsResult>;
+    sessionConfigCompletions(params: IAgentSessionConfigCompletionsParams): Promise<SessionConfigCompletionsResult>;
     /** Send a user message into an existing session. */
-    sendMessage(session: URI, prompt: string, attachments?: IAgentAttachment[], turnId?: string): Promise<void>;
+    sendMessage(session: URI, prompt: string, attachments?: readonly MessageAttachment[], turnId?: string): Promise<void>;
     /**
      * Called when the session's pending (steering) message changes.
      * The agent harness decides how to react — e.g. inject steering
@@ -345,27 +346,52 @@ export interface IAgent {
      * Queued messages are consumed on the server side and are not
      * forwarded to the agent; `queuedMessages` will always be empty.
      */
-    setPendingMessages?(session: URI, steeringMessage: IPendingMessage | undefined, queuedMessages: readonly IPendingMessage[]): void;
-    /** Retrieve all session events/messages for reconstruction. */
-    getSessionMessages(session: URI): Promise<(IAgentMessageEvent | IAgentToolStartEvent | IAgentToolCompleteEvent | IAgentSubagentStartedEvent)[]>;
+    setPendingMessages?(session: URI, steeringMessage: PendingMessage | undefined, queuedMessages: readonly PendingMessage[]): void;
+    /**
+     * Retrieve the reconstructed turns for a session, used when restoring
+     * sessions from persistent storage. Each agent owns the conversion from
+     * its SDK-specific event log to protocol {@link Turn}s, including
+     * subagent sessions (callers pass the subagent URI to retrieve the
+     * child session's turns).
+     */
+    getSessionMessages(session: URI): Promise<readonly Turn[]>;
     /** Dispose a session, freeing resources. */
     disposeSession(session: URI): Promise<void>;
     /** Abort the current turn, stopping any in-flight processing. */
     abortSession(session: URI): Promise<void>;
     /** Change the model for an existing session. */
-    changeModel(session: URI, model: IModelSelection): Promise<void>;
+    changeModel(session: URI, model: ModelSelection): Promise<void>;
     /** Respond to a pending permission request from the SDK. */
     respondToPermissionRequest(requestId: string, approved: boolean): void;
     /** Respond to a pending user input request from the SDK's ask_user tool. */
-    respondToUserInputRequest(requestId: string, response: SessionInputResponseKind, answers?: Record<string, ISessionInputAnswer>): void;
+    respondToUserInputRequest(requestId: string, response: SessionInputResponseKind, answers?: Record<string, SessionInputAnswer>): void;
     /** Return the descriptor for this agent. */
     getDescriptor(): IAgentDescriptor;
     /** Available models from this provider. */
     readonly models: IObservable<readonly IAgentModelInfo[]>;
     /** List persisted sessions from this provider. */
     listSessions(): Promise<IAgentSessionMetadata[]>;
+    /** Retrieve metadata for a single persisted session, without enumerating the provider catalog. */
+    getSessionMetadata?(session: URI): Promise<IAgentSessionMetadata | undefined>;
     /** Declare protected resources this agent requires auth for (RFC 9728). */
-    getProtectedResources(): IProtectedResourceMetadata[];
+    getProtectedResources(): ProtectedResourceMetadata[];
+    /**
+     * Fires when the agent's host-owned customizations change
+     * (loading state, resolution results, etc.), so infrastructure
+     * can republish {@link AgentInfo} and session customization state.
+     */
+    readonly onDidCustomizationsChange?: Event<void>;
+    /**
+     * Returns the host-owned customization refs this agent currently exposes.
+     *
+     * Used to publish baseline customization metadata on {@link AgentInfo}.
+     */
+    getCustomizations?(): readonly CustomizationRef[];
+    /**
+     * Returns the effective customization list for a session, including
+     * source, enablement, and loading/error status.
+     */
+    getSessionCustomizations?(session: URI): Promise<readonly SessionCustomization[]>;
     /**
      * Authenticate for a specific resource. Returns true if accepted.
      * The `resource` matches {@link IAuthorizationProtectedResourceMetadata.resource}.
@@ -377,6 +403,13 @@ export interface IAgent {
      * Optional — not all providers support truncation.
      */
     truncateSession?(session: URI, turnId?: string): Promise<void>;
+    /**
+     * Notifies the provider that a session's archived state has changed.
+     * Providers may use this to clean up or restore per-session resources
+     * (for example, removing a session-owned worktree on archive and
+     * recreating it on unarchive). Optional.
+     */
+    onArchivedChanged?(session: URI, isArchived: boolean): Promise<void>;
     /**
      * Receives client-provided customization refs and syncs them (e.g. copies
      * plugin files to local storage). Returns per-customization status with
@@ -384,7 +417,7 @@ export interface IAgent {
      *
      * The agent MAY defer a client restart until all active sessions are idle.
      */
-    setClientCustomizations(clientId: string, customizations: ICustomizationRef[], progress?: (results: ISyncedCustomization[]) => void): Promise<ISyncedCustomization[]>;
+    setClientCustomizations(clientId: string, customizations: CustomizationRef[], progress?: (results: ISyncedCustomization[]) => void): Promise<ISyncedCustomization[]>;
     /**
      * Receives client-provided tool definitions to make available in a
      * specific session. The agent registers these as custom tools so the
@@ -397,14 +430,16 @@ export interface IAgent {
      * @param clientId The client that owns these tools.
      * @param tools The tool definitions (full replacement).
      */
-    setClientTools(session: URI, clientId: string, tools: IToolDefinition[]): void;
+    setClientTools(session: URI, clientId: string, tools: ToolDefinition[]): void;
     /**
      * Called when a client completes a client-provided tool call.
      * Resolves the tool handler's deferred promise so the SDK can continue.
      *
      * @param session The session the tool call belongs to.
+     * @param toolCallId The id of the tool call being completed.
+     * @param result The result of the tool call.
      */
-    onClientToolCallComplete(session: URI, toolCallId: string, result: IToolCallResult): void;
+    onClientToolCallComplete(session: URI, toolCallId: string, result: ToolCallResult): void;
     /**
      * Notifies the agent that a customization has been toggled on or off.
      * The agent MAY restart its client before the next message is sent.
@@ -425,25 +460,31 @@ export interface IAgent {
 export interface IAgentConnection {
     readonly _serviceBrand: undefined;
     readonly clientId: string;
-    readonly rootState: IAgentSubscription<IRootState>;
+    readonly rootState: IAgentSubscription<RootState>;
     getSubscription<T extends StateComponents>(kind: T, resource: URI): IReference<IAgentSubscription<ComponentToState[T]>>;
     getSubscriptionUnmanaged<T extends StateComponents>(kind: T, resource: URI): IAgentSubscription<ComponentToState[T]> | undefined;
-    dispatch(action: ISessionAction | ITerminalAction): void;
+    dispatch(action: SessionAction | TerminalAction | IRootConfigChangedAction): void;
     readonly onDidNotification: Event<INotification>;
-    readonly onDidAction: Event<IActionEnvelope>;
-    authenticate(params: IAuthenticateParams): Promise<IAuthenticateResult>;
+    readonly onDidAction: Event<ActionEnvelope>;
+    authenticate(params: AuthenticateParams): Promise<AuthenticateResult>;
     listSessions(): Promise<IAgentSessionMetadata[]>;
     createSession(config?: IAgentCreateSessionConfig): Promise<URI>;
-    resolveSessionConfig(params: IAgentResolveSessionConfigParams): Promise<IResolveSessionConfigResult>;
-    sessionConfigCompletions(params: IAgentSessionConfigCompletionsParams): Promise<ISessionConfigCompletionsResult>;
+    resolveSessionConfig(params: IAgentResolveSessionConfigParams): Promise<ResolveSessionConfigResult>;
+    sessionConfigCompletions(params: IAgentSessionConfigCompletionsParams): Promise<SessionConfigCompletionsResult>;
+    completions(params: CompletionsParams): Promise<CompletionsResult>;
+    /**
+     * Trigger characters announced by the connected agent host that should
+     * cause the client to issue a `completions` request when typed in a
+     * user-message input. Resolves once on first request and is cached.
+     */
+    getCompletionTriggerCharacters(): Promise<readonly string[]>;
     disposeSession(session: URI): Promise<void>;
-    createTerminal(params: ICreateTerminalParams): Promise<void>;
+    createTerminal(params: CreateTerminalParams): Promise<void>;
     disposeTerminal(terminal: URI): Promise<void>;
-    resourceList(uri: URI): Promise<IResourceListResult>;
-    resourceRead(uri: URI): Promise<IResourceReadResult>;
-    resourceWrite(params: IResourceWriteParams): Promise<IResourceWriteResult>;
-    resourceCopy(params: IResourceCopyParams): Promise<IResourceCopyResult>;
-    resourceDelete(params: IResourceDeleteParams): Promise<IResourceDeleteResult>;
-    resourceMove(params: IResourceMoveParams): Promise<IResourceMoveResult>;
+    resourceList(uri: URI): Promise<ResourceListResult>;
+    resourceRead(uri: URI): Promise<ResourceReadResult>;
+    resourceWrite(params: ResourceWriteParams): Promise<ResourceWriteResult>;
+    resourceCopy(params: ResourceCopyParams): Promise<ResourceCopyResult>;
+    resourceDelete(params: ResourceDeleteParams): Promise<ResourceDeleteResult>;
+    resourceMove(params: ResourceMoveParams): Promise<ResourceMoveResult>;
 }
-export {};

package/vscode/src/vs/platform/agentHost/common/agentService.js

@@ -9,6 +9,8 @@ var AgentHostIpcChannels;
 })(AgentHostIpcChannels || (AgentHostIpcChannels = {}));
 const AgentHostEnabledSettingId = "chat.agentHost.enabled";
 const AgentHostIpcLoggingSettingId = "chat.agentHost.ipcLoggingEnabled";
+const AgentHostAhpJsonlLoggingSettingId = "chat.agentHost.ahpJsonlLoggingEnabled";
+const AgentHostClaudeAgentSdkPathSettingId = "chat.agentHost.claudeAgent.path";
 var AgentSession;
 (function(AgentSession) {
     function uri(provider, rawSessionId) {
@@ -30,4 +32,4 @@ var AgentSession;
     AgentSession.provider = provider;
 })(AgentSession || (AgentSession = {}));
 
-export { AgentHostEnabledSettingId, AgentHostIpcChannels, AgentHostIpcLoggingSettingId, AgentSession };
+export { AgentHostAhpJsonlLoggingSettingId, AgentHostClaudeAgentSdkPathSettingId, AgentHostEnabledSettingId, AgentHostIpcChannels, AgentHostIpcLoggingSettingId, AgentSession };