@codingame/monaco-vscode-chat-service-override 34.1.3 → 35.0.1

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

@@ -1,6 +1,8 @@
 
 import { isWeb } from '@codingame/monaco-vscode-api/vscode/vs/base/common/platform';
+import { truncate } from '@codingame/monaco-vscode-api/vscode/vs/base/common/strings';
 import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+import { parseRequiredSessionUriFromChatUri, buildSubagentChatUri } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionState';
 
 var AgentHostIpcChannels;
 (function(AgentHostIpcChannels) {
@@ -15,16 +17,57 @@ function isAgentHostEnabled(configurationService) {
 }
 const AgentHostAhpJsonlLoggingSettingId = "chat.agentHost.ahpJsonlLoggingEnabled";
 const AgentHostCustomTerminalToolEnabledSettingId = "chat.agentHost.customTerminalTool.enabled";
-const AgentHostClaudeAgentSdkPathSettingId = "chat.agentHost.claudeAgent.path";
-const AgentHostCodexAgentBinaryPathSettingId = "chat.agentHost.codexAgent.path";
+const AgentHostOpus48PromptEnabledSettingId = "chat.agentHost.opus48Prompt.enabled";
+const AgentHostClaudeAgentEnabledSettingId = "chat.agentHost.claudeAgent.enabled";
+const AgentHostCodexAgentEnabledSettingId = "chat.agentHost.codexAgent.enabled";
+const AgentHostByokModelsEnabledSettingId = "chat.agentHost.byokModels.enabled";
+const AgentHostSdkSandboxEnabledSettingId = "chat.agentHost.sdkSandbox.enabled";
+const ClaudePreferAgentHostAgentsSettingId = "chat.agents.claude.preferAgentHost";
+const ClaudePreferAgentHostEditorSettingId = "chat.editor.claude.preferAgentHost";
+const AgentHostCodexAgentSdkRootSettingId = "chat.agentHost.codexAgent.sdkRoot";
 const AgentHostCodexAgentCodexHomeSettingId = "chat.agentHost.codexAgent.codexHome";
 const AgentHostCodexAgentBinaryArgsSettingId = "chat.agentHost.codexAgent.binaryArgs";
 const AgentHostOTelEnabledSettingId = "chat.agentHost.otel.enabled";
 const AgentHostOTelExporterTypeSettingId = "chat.agentHost.otel.exporterType";
+const AgentHostOTelOtlpProtocolSettingId = "chat.agentHost.otel.otlpProtocol";
 const AgentHostOTelOtlpEndpointSettingId = "chat.agentHost.otel.otlpEndpoint";
 const AgentHostOTelCaptureContentSettingId = "chat.agentHost.otel.captureContent";
 const AgentHostOTelOutfileSettingId = "chat.agentHost.otel.outfile";
+const AgentHostOTelServiceNameSettingId = "chat.agentHost.otel.serviceName";
+const AgentHostOTelResourceAttributesSettingId = "chat.agentHost.otel.resourceAttributes";
 const AgentHostOTelDbSpanExporterEnabledSettingId = "chat.agentHost.otel.dbSpanExporter.enabled";
+const SUBAGENT_CHAT_TITLE_MAX_LENGTH = 60;
+function subagentChatTitle(taskDescription, agentDisplayName) {
+    const task = taskDescription?.trim();
+    if (task) {
+        return truncate(task, SUBAGENT_CHAT_TITLE_MAX_LENGTH);
+    }
+    return agentDisplayName?.trim() || "Subagent";
+}
+var SubagentChatSignal;
+(function(SubagentChatSignal) {
+    function toSpawnEvent(signal) {
+        if (signal.kind !== "subagent_started") {
+            return undefined;
+        }
+        let session;
+        try {
+            session = parseRequiredSessionUriFromChatUri(signal.chat);
+        } catch {
+            return undefined;
+        }
+        return {
+            session: ( URI.parse(session)),
+            chat: ( URI.parse(buildSubagentChatUri(session, signal.toolCallId))),
+            parent: {
+                chat: signal.chat,
+                toolCallId: signal.toolCallId
+            },
+            title: subagentChatTitle(signal.taskDescription, signal.agentDisplayName)
+        };
+    }
+    SubagentChatSignal.toSpawnEvent = toSpawnEvent;
+})(SubagentChatSignal || (SubagentChatSignal = {}));
 var AgentSession;
 (function(AgentSession) {
     function uri(provider, rawSessionId) {
@@ -46,4 +89,4 @@ var AgentSession;
     AgentSession.provider = provider;
 })(AgentSession || (AgentSession = {}));
 
-export { AgentHostAhpJsonlLoggingSettingId, AgentHostClaudeAgentSdkPathSettingId, AgentHostCodexAgentBinaryArgsSettingId, AgentHostCodexAgentBinaryPathSettingId, AgentHostCodexAgentCodexHomeSettingId, AgentHostCustomTerminalToolEnabledSettingId, AgentHostEnabledSettingId, AgentHostIpcChannels, AgentHostOTelCaptureContentSettingId, AgentHostOTelDbSpanExporterEnabledSettingId, AgentHostOTelEnabledSettingId, AgentHostOTelExporterTypeSettingId, AgentHostOTelOtlpEndpointSettingId, AgentHostOTelOutfileSettingId, AgentSession, isAgentHostEnabled };
+export { AgentHostAhpJsonlLoggingSettingId, AgentHostByokModelsEnabledSettingId, AgentHostClaudeAgentEnabledSettingId, AgentHostCodexAgentBinaryArgsSettingId, AgentHostCodexAgentCodexHomeSettingId, AgentHostCodexAgentEnabledSettingId, AgentHostCodexAgentSdkRootSettingId, AgentHostCustomTerminalToolEnabledSettingId, AgentHostEnabledSettingId, AgentHostIpcChannels, AgentHostOTelCaptureContentSettingId, AgentHostOTelDbSpanExporterEnabledSettingId, AgentHostOTelEnabledSettingId, AgentHostOTelExporterTypeSettingId, AgentHostOTelOtlpEndpointSettingId, AgentHostOTelOtlpProtocolSettingId, AgentHostOTelOutfileSettingId, AgentHostOTelResourceAttributesSettingId, AgentHostOTelServiceNameSettingId, AgentHostOpus48PromptEnabledSettingId, AgentHostSdkSandboxEnabledSettingId, AgentSession, ClaudePreferAgentHostAgentsSettingId, ClaudePreferAgentHostEditorSettingId, SubagentChatSignal, isAgentHostEnabled, subagentChatTitle };

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

@@ -1,6 +1,7 @@
 
 import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-root/state';
 import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-session/state';
+import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-chat/state';
 import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-terminal/state';
 import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-changeset/state';
 import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-resource-watch/state';

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

@@ -0,0 +1 @@
+export declare function isFileResourceRead(method: string, params: unknown): boolean;

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

@@ -0,0 +1,26 @@
+
+import { Schemas } from '@codingame/monaco-vscode-api/vscode/vs/base/common/network';
+import { hasKey } from '@codingame/monaco-vscode-api/vscode/vs/base/common/types';
+import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
+
+function isFileResourceRead(method, params) {
+    if (method !== "resourceRead" || !hasUriParam(params)) {
+        return false;
+    }
+    const uri = params.uri;
+    if (typeof uri !== "string") {
+        return false;
+    }
+    try {
+        return ( URI.parse(uri)).scheme === Schemas.file;
+    } catch {
+        return false;
+    }
+}
+function hasUriParam(params) {
+    return typeof params === "object" && params !== null && hasKey(params, {
+        uri: true
+    });
+}
+
+export { isFileResourceRead };

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

@@ -18,8 +18,8 @@ export declare enum AgentHostSandboxConfigKey {
 export declare enum AgentHostSandboxKey {
     Enabled = "enabled",
     WindowsEnabled = "enabled.windows",
+    AllowNetwork = "allowNetwork",
     AllowUnsandboxedCommands = "allowUnsandboxedCommands",
-    AutoApproveUnsandboxedCommands = "autoApproveUnsandboxedCommands",
     LinuxFileSystem = "fileSystem.linux",
     MacFileSystem = "fileSystem.mac",
     WindowsFileSystem = "fileSystem.windows",
@@ -31,8 +31,8 @@ export declare enum AgentHostSandboxKey {
 export type ISandboxConfigValue = Partial<{
     [AgentHostSandboxKey.Enabled]: AgentSandboxEnabledValue;
     [AgentHostSandboxKey.WindowsEnabled]: AgentSandboxEnabledValue;
+    [AgentHostSandboxKey.AllowNetwork]: boolean;
     [AgentHostSandboxKey.AllowUnsandboxedCommands]: boolean;
-    [AgentHostSandboxKey.AutoApproveUnsandboxedCommands]: boolean;
     [AgentHostSandboxKey.LinuxFileSystem]: Record<string, unknown>;
     [AgentHostSandboxKey.MacFileSystem]: Record<string, unknown>;
     [AgentHostSandboxKey.WindowsFileSystem]: Record<string, unknown>;
@@ -49,8 +49,8 @@ export type ISandboxConfigValue = Partial<{
  * normalized form of each setting is declared here — the workbench is
  * expected to:
  *
- *  - map the legacy boolean form of `chat.agent.sandbox.enabled` to the
- *    `'on' | 'off' | 'allowNetwork'` enum, and
+ *  - map legacy boolean sandbox enabled values to the `'on' | 'off' | 'allowNetwork'`
+ *    agent-host enum, and
  *  - migrate values from any deprecated setting IDs to their modern key
  *
  * before pushing a `RootConfigChanged` action. That keeps the agent-host
@@ -60,8 +60,8 @@ export declare const sandboxConfigSchema: import("./agentHostSchema.js").ISchema
     sandbox: import("./agentHostSchema.js").ISchemaProperty<Partial<{
         enabled: AgentSandboxEnabledValue;
         "enabled.windows": AgentSandboxEnabledValue;
+        allowNetwork: boolean;
         allowUnsandboxedCommands: boolean;
-        autoApproveUnsandboxedCommands: boolean;
         "fileSystem.linux": Record<string, unknown>;
         "fileSystem.mac": Record<string, unknown>;
         "fileSystem.windows": Record<string, unknown>;

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

@@ -12,8 +12,8 @@ var AgentHostSandboxKey;
 (function(AgentHostSandboxKey) {
     AgentHostSandboxKey["Enabled"] = "enabled";
     AgentHostSandboxKey["WindowsEnabled"] = "enabled.windows";
+    AgentHostSandboxKey["AllowNetwork"] = "allowNetwork";
     AgentHostSandboxKey["AllowUnsandboxedCommands"] = "allowUnsandboxedCommands";
-    AgentHostSandboxKey["AutoApproveUnsandboxedCommands"] = "autoApproveUnsandboxedCommands";
     AgentHostSandboxKey["LinuxFileSystem"] = "fileSystem.linux";
     AgentHostSandboxKey["MacFileSystem"] = "fileSystem.mac";
     AgentHostSandboxKey["WindowsFileSystem"] = "fileSystem.windows";
@@ -24,11 +24,11 @@ var AgentHostSandboxKey;
 createSchema({
     [AgentHostSandboxConfigKey.Sandbox]: schemaProperty({
         type: "object",
-        title: ( localize(1858, "Agent Sandbox")),
+        title: ( localize(1920, "Agent Sandbox")),
         properties: {
             [AgentHostSandboxKey.Enabled]: {
                 type: "string",
-                title: ( localize(1859, "Sandbox Enabled")),
+                title: ( localize(1921, "Sandbox Enabled")),
                 enum: [
                     AgentSandboxEnabledValue.Off,
                     AgentSandboxEnabledValue.On,
@@ -37,51 +37,51 @@ createSchema({
             },
             [AgentHostSandboxKey.WindowsEnabled]: {
                 type: "string",
-                title: ( localize(1860, "Sandbox Enabled (Windows)")),
+                title: ( localize(1922, "Sandbox Enabled (Windows)")),
                 enum: [
                     AgentSandboxEnabledValue.Off,
                     AgentSandboxEnabledValue.On,
                     AgentSandboxEnabledValue.AllowNetwork
                 ]
             },
-            [AgentHostSandboxKey.AllowUnsandboxedCommands]: {
+            [AgentHostSandboxKey.AllowNetwork]: {
                 type: "boolean",
-                title: ( localize(1861, "Allow Unsandboxed Commands"))
+                title: ( localize(1923, "Allow Network"))
             },
-            [AgentHostSandboxKey.AutoApproveUnsandboxedCommands]: {
+            [AgentHostSandboxKey.AllowUnsandboxedCommands]: {
                 type: "boolean",
-                title: ( localize(1862, "Auto-Approve Unsandboxed Commands"))
+                title: ( localize(1924, "Allow Unsandboxed Commands"))
             },
             [AgentHostSandboxKey.LinuxFileSystem]: {
                 type: "object",
-                title: ( localize(1863, "Linux Sandbox Filesystem"))
+                title: ( localize(1925, "Linux Sandbox Filesystem"))
             },
             [AgentHostSandboxKey.MacFileSystem]: {
                 type: "object",
-                title: ( localize(1864, "macOS Sandbox Filesystem"))
+                title: ( localize(1926, "macOS Sandbox Filesystem"))
             },
             [AgentHostSandboxKey.WindowsFileSystem]: {
                 type: "object",
-                title: ( localize(1865, "Windows Sandbox Filesystem"))
+                title: ( localize(1927, "Windows Sandbox Filesystem"))
             },
             [AgentHostSandboxKey.AdvancedRuntime]: {
                 type: "object",
-                title: ( localize(1866, "Advanced Sandbox Runtime"))
+                title: ( localize(1928, "Advanced Sandbox Runtime"))
             },
             [AgentHostSandboxKey.AllowedNetworkDomains]: {
                 type: "array",
-                title: ( localize(1867, "Allowed Network Domains")),
+                title: ( localize(1929, "Allowed Network Domains")),
                 items: {
                     type: "string",
-                    title: ( localize(1868, "Domain"))
+                    title: ( localize(1930, "Domain"))
                 }
             },
             [AgentHostSandboxKey.DeniedNetworkDomains]: {
                 type: "array",
-                title: ( localize(1869, "Denied Network Domains")),
+                title: ( localize(1931, "Denied Network Domains")),
                 items: {
                     type: "string",
-                    title: ( localize(1870, "Domain"))
+                    title: ( localize(1932, "Domain"))
                 }
             }
         }
@@ -90,8 +90,8 @@ createSchema({
 const sandboxSettingIdToAgentHostKey = {
     [AgentSandboxSettingId.AgentSandboxEnabled]: AgentHostSandboxKey.Enabled,
     [AgentSandboxSettingId.AgentSandboxWindowsEnabled]: AgentHostSandboxKey.WindowsEnabled,
+    [AgentSandboxSettingId.AgentSandboxAllowNetwork]: AgentHostSandboxKey.AllowNetwork,
     [AgentSandboxSettingId.AgentSandboxAllowUnsandboxedCommands]: AgentHostSandboxKey.AllowUnsandboxedCommands,
-    [AgentSandboxSettingId.AgentSandboxAutoApproveUnsandboxedCommands]: AgentHostSandboxKey.AutoApproveUnsandboxedCommands,
     [AgentSandboxSettingId.AgentSandboxLinuxFileSystem]: AgentHostSandboxKey.LinuxFileSystem,
     [AgentSandboxSettingId.AgentSandboxMacFileSystem]: AgentHostSandboxKey.MacFileSystem,
     [AgentSandboxSettingId.AgentSandboxWindowsFileSystem]: AgentHostSandboxKey.WindowsFileSystem,

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

@@ -2,9 +2,9 @@ import { Emitter, Event } from "@codingame/monaco-vscode-api/vscode/vs/base/comm
 import { Disposable, IReference } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
 import { IObservable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/observable";
 import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
-import { ActionEnvelope, IRootConfigChangedAction, SessionAction, StateAction } from "./sessionActions.js";
+import { ActionEnvelope, ChatAction, AnnotationsAction, ClientAnnotationsAction, IRootConfigChangedAction, SessionAction, StateAction } from "./sessionActions.js";
 import type { TerminalAction } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/action-origin.generated";
-import type { ChangesetState, RootState, SessionState, TerminalState } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/state";
+import type { AnnotationsState, ChangesetState, ChatState, RootState, SessionState, TerminalState } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/state";
 import type { IStateSnapshot } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionProtocol";
 import { StateComponents } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionState";
 /**
@@ -31,6 +31,8 @@ export interface IAgentSubscription<T> {
     readonly verifiedValue: T | undefined;
     /** Fires when {@link value} changes (optimistic or confirmed). */
     readonly onDidChange: Event<T>;
+    /** Fires when the subscription enters an error state. */
+    readonly onDidError?: Event<Error>;
     /** Fires before a server-originated action is applied to this subscription's state. */
     readonly onWillApplyAction: Event<ActionEnvelope>;
     /** Fires after a server-originated action is applied to this subscription's state. */
@@ -79,6 +81,8 @@ declare abstract class BaseAgentSubscription<T> extends Disposable implements IA
     private _bufferedEnvelopes;
     protected readonly _onDidChange: Emitter<T>;
     readonly onDidChange: Event<T>;
+    protected readonly _onDidError: Emitter<Error>;
+    readonly onDidError: Event<Error>;
     protected readonly _onWillApplyAction: Emitter<ActionEnvelope>;
     readonly onWillApplyAction: Event<ActionEnvelope>;
     protected readonly _onDidApplyAction: Emitter<ActionEnvelope>;
@@ -123,13 +127,18 @@ export declare class RootStateSubscription extends BaseAgentSubscription<RootSta
     protected _applyReducer(state: RootState, action: StateAction): RootState;
     protected _isRelevantEnvelope(envelope: ActionEnvelope): boolean;
 }
-interface IPendingAction {
+/**
+ * A pending optimistic action awaiting server confirmation, paired with the
+ * channel it was dispatched to so it can be replayed across a reconnect. The
+ * channel is a session channel for {@link SessionStateSubscription} actions and
+ * a chat channel for {@link ChatStateSubscription} actions.
+ */
+export interface IPendingDispatchAction {
     readonly clientSeq: number;
-    readonly action: SessionAction;
-}
-export interface IPendingSessionAction extends IPendingAction {
-    /** URI of the session this action targets, as stored on the subscription. */
-    readonly sessionUri: string;
+    /** The optimistic action awaiting confirmation. */
+    readonly action: SessionAction | ChatAction;
+    /** URI of the channel this action targets, as stored on the subscription. */
+    readonly channel: string;
 }
 /**
  * Subscription to a session at `copilot:/<uuid>`.
@@ -151,7 +160,6 @@ export declare class SessionStateSubscription extends BaseAgentSubscription<Sess
     protected _isRelevantEnvelope(envelope: ActionEnvelope): boolean;
     protected _onSnapshotApplied(fromSeq: number): void;
     protected _reconcile(envelope: ActionEnvelope, isOwnAction: boolean): void;
-    private _promotePendingTurnStartIfTerminal;
     private _confirmedApply;
     private _recomputeOptimistic;
     /**
@@ -165,7 +173,7 @@ export declare class SessionStateSubscription extends BaseAgentSubscription<Sess
      * to reflect them — the client must explicitly drop entries echoed back
      * by the server.
      */
-    getPendingActions(): IPendingSessionAction[];
+    getPendingActions(): IPendingDispatchAction[];
     /**
      * Drop the pending entry whose `clientSeq` matches the supplied value.
      * Used during reconnect to evict actions the server already echoed back
@@ -173,6 +181,36 @@ export declare class SessionStateSubscription extends BaseAgentSubscription<Sess
      */
     dropPendingByClientSeq(clientSeq: number): boolean;
 }
+/**
+ * Subscription to a chat channel (e.g. a session's default chat URI). Turns,
+ * tool calls and pending/input state moved off the session onto the chat
+ * channel in the multi-chat protocol, so this subscription carries the
+ * conversation contents. Supports write-ahead reconciliation for
+ * client-dispatchable chat actions (turn starts, confirmations, etc.).
+ */
+export declare class ChatStateSubscription extends BaseAgentSubscription<ChatState> {
+    private readonly _pendingActions;
+    private _optimisticState;
+    private readonly _chatUri;
+    private readonly _seqAllocator;
+    constructor(chatUri: string, clientId: string, seqAllocator: () => number, log: (msg: string) => void);
+    /**
+     * Optimistically apply a chat action. Returns the clientSeq to send to
+     * the server so it can echo back for reconciliation.
+     */
+    applyOptimistic(action: ChatAction): number;
+    protected _getOptimisticState(): ChatState | undefined;
+    protected _applyReducer(state: ChatState, action: StateAction): ChatState;
+    protected _isRelevantEnvelope(envelope: ActionEnvelope): boolean;
+    protected _onSnapshotApplied(fromSeq: number): void;
+    protected _reconcile(envelope: ActionEnvelope, isOwnAction: boolean): void;
+    private _promotePendingTurnStartIfTerminal;
+    private _confirmedApply;
+    private _recomputeOptimistic;
+    clearPending(): void;
+    getPendingActions(): IPendingDispatchAction[];
+    dropPendingByClientSeq(clientSeq: number): boolean;
+}
 /**
  * Subscription to a terminal at an agent-host terminal URI.
  * Server-only mutations — no write-ahead (terminal I/O is side-effect-only).
@@ -202,6 +240,37 @@ export declare class ChangesetStateSubscription extends BaseAgentSubscription<Ch
     protected _applyReducer(state: ChangesetState, action: StateAction): ChangesetState;
     protected _isRelevantEnvelope(envelope: ActionEnvelope): boolean;
 }
+/**
+ * Subscription to a session's annotations channel (e.g.
+ * `<sessionUri>/annotations`).
+ *
+ * Annotations actions are client-dispatchable, so this subscription supports
+ * write-ahead reconciliation: optimistic state is layered on top of confirmed
+ * state and reconciled as the server echoes the client's own actions back.
+ *
+ * Like {@link ChangesetStateSubscription}, the subscription does NOT
+ * self-tear-down on lifecycle events; cleanup is driven externally by the
+ * holder releasing its `IReference`.
+ */
+export declare class AnnotationsStateSubscription extends BaseAgentSubscription<AnnotationsState> {
+    private readonly _pendingActions;
+    private _optimisticState;
+    private readonly _annotationsUri;
+    private readonly _seqAllocator;
+    constructor(annotationsUri: string, clientId: string, seqAllocator: () => number, log: (msg: string) => void);
+    /**
+     * Optimistically apply an annotations action. Returns the clientSeq to
+     * send to the server so it can echo back for reconciliation.
+     */
+    applyOptimistic(action: AnnotationsAction): number;
+    protected _getOptimisticState(): AnnotationsState | undefined;
+    protected _applyReducer(state: AnnotationsState, action: StateAction): AnnotationsState;
+    protected _isRelevantEnvelope(envelope: ActionEnvelope): boolean;
+    protected _onSnapshotApplied(fromSeq: number): void;
+    protected _reconcile(envelope: ActionEnvelope, isOwnAction: boolean): void;
+    private _confirmedApply;
+    private _recomputeOptimistic;
+}
 /**
  * Manages the lifecycle of resource subscriptions for an agent connection.
  *
@@ -214,6 +283,7 @@ export declare class ChangesetStateSubscription extends BaseAgentSubscription<Ch
  */
 export declare class AgentSubscriptionManager extends Disposable {
     private readonly _subscriptions;
+    private readonly _inflightCreates;
     private _referenceOwnerIds;
     private readonly _rootState;
     private readonly _clientId;
@@ -234,6 +304,18 @@ export declare class AgentSubscriptionManager extends Disposable {
      * Returns `undefined` if no subscription is active for the given resource.
      */
     getSubscriptionUnmanaged<T>(resource: URI): IAgentSubscription<T> | undefined;
+    /**
+     * Returns the in-flight `createSession` Promise for this URI, or `undefined` if no create is pending. Used by
+     * callers that need to gate their own work on a still-running eager `createSession` (e.g. the chat handler awaits
+     * this before deciding whether the sessions provider's eager-create raced first send).
+     */
+    getInflightSessionCreate(resource: URI): Promise<unknown> | undefined;
+    /**
+     * Register an in-flight `createSession` Promise for a session URI. Any
+     * subscribe issued for this resource while the create is pending waits
+     * for the Promise before issuing the wire-level subscribe.
+     */
+    trackSessionCreate(resource: URI, promise: Promise<unknown>): void;
     /**
      * Get or create a refcounted subscription to any resource. Disposing
      * the returned reference decrements the refcount; when it reaches zero
@@ -265,7 +347,7 @@ export declare class AgentSubscriptionManager extends Disposable {
      * `channel` is the protocol URI string identifying the channel the
      * action targets (a session URI for session actions, etc.).
      */
-    dispatchOptimistic(channel: string, action: SessionAction | TerminalAction | IRootConfigChangedAction): number;
+    dispatchOptimistic(channel: string, action: SessionAction | ChatAction | TerminalAction | ClientAnnotationsAction | IRootConfigChangedAction): number;
     /**
      * URIs currently subscribed to via {@link getSubscription}. Used to
      * build the `subscriptions` payload for a `reconnect` RPC so the
@@ -290,7 +372,7 @@ export declare class AgentSubscriptionManager extends Disposable {
      * either echoed back by the server or explicitly dropped via
      * {@link dropPendingSessionAction}.
      */
-    getPendingSessionActions(): IPendingSessionAction[];
+    getPendingSessionActions(): IPendingDispatchAction[];
     /**
      * Remove a single pending optimistic action for a session by its
      * `clientSeq`. Used during reconnect to evict actions the server
@@ -316,6 +398,8 @@ export declare class AgentSubscriptionManager extends Disposable {
     private _releaseSubscription;
     dispose(): void;
 }
+/** Returns whether an action envelope targets one of the subscribed channel URIs. */
+export declare function isActionEnvelopeRelevantToSubscriptionUris(envelope: ActionEnvelope, subscribedUris: Iterable<string>): boolean;
 /**
  * Adapts an {@link IAgentSubscription} into an {@link IObservable} of the
  * subscription's value. Errors and the pre-snapshot phase are surfaced as