@codingame/monaco-vscode-chat-service-override 33.0.8 → 34.0.0

package/vscode/src/vs/platform/agentHost/common/agentHostStarter.config.contribution.js

@@ -0,0 +1,119 @@
+
+import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
+import { Extensions } from '@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configurationRegistry';
+import product from '@codingame/monaco-vscode-api/vscode/vs/platform/product/common/product';
+import { Registry } from '@codingame/monaco-vscode-api/vscode/vs/platform/registry/common/platform';
+import { AgentHostOTelDbSpanExporterEnabledSettingId, AgentHostOTelOutfileSettingId, AgentHostOTelCaptureContentSettingId, AgentHostOTelOtlpEndpointSettingId, AgentHostOTelExporterTypeSettingId, AgentHostOTelEnabledSettingId, AgentHostCodexAgentBinaryArgsSettingId, AgentHostCodexAgentCodexHomeSettingId, AgentHostCodexAgentBinaryPathSettingId, AgentHostClaudeAgentSdkPathSettingId } from './agentService.js';
+
+const configurationRegistry = ( Registry.as(Extensions.Configuration));
+configurationRegistry.registerConfiguration({
+    id: "chatAgentHostStarter",
+    title: ( localize(1847, "Chat Agent Host Starter")),
+    type: "object",
+    properties: {
+        [AgentHostClaudeAgentSdkPathSettingId]: {
+            type: "string",
+            description: ( localize(
+                1848,
+                "Experimental, for local testing only. Absolute path to a locally-installed `@anthropic-ai/claude-agent-sdk` package. When set, the Claude agent provider is registered inside the agent host and the SDK is loaded from this path. Requires `#chat.agentHost.enabled#`. The agent host process must be restarted for changes to take effect. This setting will be removed once the SDK is delivered through the Extension Marketplace."
+            )),
+            default: "",
+            tags: ["experimental", "advanced"],
+            included: product.quality !== "stable"
+        },
+        [AgentHostCodexAgentBinaryPathSettingId]: {
+            type: "string",
+            description: ( localize(
+                1849,
+                "Experimental, for local testing only. Absolute path to a locally-installed `codex` binary. When set, the Codex agent provider is registered inside the agent host and `codex app-server` is spawned from this path. Requires `#chat.agentHost.enabled#`. The agent host process must be restarted for changes to take effect."
+            )),
+            default: "",
+            tags: ["experimental", "advanced"],
+            included: product.quality !== "stable"
+        },
+        [AgentHostCodexAgentCodexHomeSettingId]: {
+            type: "string",
+            description: ( localize(
+                1850,
+                "Optional override for `$CODEX_HOME`. Controls where the codex binary reads config and writes rollouts. When empty, codex uses its default (`~/.codex`)."
+            )),
+            default: "",
+            tags: ["experimental", "advanced"],
+            included: product.quality !== "stable"
+        },
+        [AgentHostCodexAgentBinaryArgsSettingId]: {
+            type: "array",
+            items: {
+                type: "string"
+            },
+            description: ( localize(
+                1851,
+                "Additional command-line arguments passed to `codex app-server`. Primarily useful for debugging (for example, `--log-level=debug`)."
+            )),
+            default: [],
+            tags: ["experimental", "advanced"],
+            included: product.quality !== "stable"
+        },
+        [AgentHostOTelEnabledSettingId]: {
+            type: "boolean",
+            markdownDescription: ( localize(
+                1852,
+                "When enabled, the agent host emits OpenTelemetry traces from the Copilot SDK. Requires `#chat.agentHost.enabled#`. Either configure `#chat.agentHost.otel.otlpEndpoint#` to ship traces to an external collector or enable `#chat.agentHost.otel.dbSpanExporter.enabled#` to capture them locally."
+            )),
+            default: false,
+            restricted: true,
+            tags: ["experimental", "advanced"]
+        },
+        [AgentHostOTelExporterTypeSettingId]: {
+            type: "string",
+            enum: ["otlp-http", "otlp-grpc", "console", "file"],
+            markdownDescription: ( localize(
+                1853,
+                "Exporter backend used by the Copilot SDK when `#chat.agentHost.otel.enabled#` is on. `otlp-grpc` is downgraded to `otlp-http` transparently in the CLI runtime."
+            )),
+            default: "otlp-http",
+            restricted: true,
+            tags: ["experimental", "advanced"]
+        },
+        [AgentHostOTelOtlpEndpointSettingId]: {
+            type: "string",
+            markdownDescription: ( localize(
+                1854,
+                "OTLP endpoint URL when exporter type is `otlp-http` or `otlp-grpc`. Sets `OTEL_EXPORTER_OTLP_ENDPOINT` inside the agent host process."
+            )),
+            default: "",
+            restricted: true,
+            tags: ["experimental", "advanced"]
+        },
+        [AgentHostOTelCaptureContentSettingId]: {
+            type: "boolean",
+            markdownDescription: ( localize(
+                1855,
+                "When enabled, includes prompt and response content in OTel span attributes. Sets `OTEL_INSTRUMENTATION_GENAI_CAPTURE_MESSAGE_CONTENT`. Privacy-sensitive: do not enable in environments that ship spans to shared sinks."
+            )),
+            default: false,
+            restricted: true,
+            tags: ["experimental", "advanced"]
+        },
+        [AgentHostOTelOutfileSettingId]: {
+            type: "string",
+            markdownDescription: ( localize(
+                1856,
+                "Output path for span JSON lines when exporter type is `file`. Sets `COPILOT_OTEL_FILE_EXPORTER_PATH`."
+            )),
+            default: "",
+            restricted: true,
+            tags: ["experimental", "advanced"]
+        },
+        [AgentHostOTelDbSpanExporterEnabledSettingId]: {
+            type: "boolean",
+            markdownDescription: ( localize(
+                1857,
+                "When enabled, the agent host persists every emitted OTel span to a local SQLite database. Spans can be inspected via the `Export Agent Host Traces Database` command. Compatible with external exporters: spans are written to SQLite *and* forwarded to the user-configured sink."
+            )),
+            default: false,
+            restricted: true,
+            tags: ["experimental", "advanced"]
+        }
+    }
+});

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

@@ -2,13 +2,16 @@ import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event"
 import { IReference } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
 import type { IObservable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/observable";
 import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { IConfigurationService } from "@codingame/monaco-vscode-api/vscode/vs/platform/configuration/common/configuration.service";
 import type { ISyncedCustomization } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentPluginManager";
-import type { IAgentSubscription } from "./state/agentSubscription.js";
+import type { IActiveSubscriptionInfo, IAgentSubscription } from "./state/agentSubscription.js";
+import type { IRemoteWatchHandle } from "./agentHostFileSystemProvider.js";
 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 { InvokeChangesetOperationParams, InvokeChangesetOperationResult } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/channels-changeset/commands";
+import { ProtectedResourceMetadata, type ChangesetSummary, type ConfigSchema, type MessageAttachment, type ModelSelection, type AgentSelection, 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-api/vscode/vs/platform/agentHost/common/state/sessionState";
+import type { ResourceCopyParams, ResourceCopyResult, ResourceDeleteParams, ResourceDeleteResult, ResourceListResult, ResourceMkdirParams, ResourceMkdirResult, ResourceMoveParams, ResourceMoveResult, ResourceReadResult, ResourceResolveParams, ResourceResolveResult, ResourceWriteParams, ResourceWriteResult, CreateResourceWatchParams, CreateResourceWatchResult } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionProtocol";
+import { ComponentToState, SessionInputResponseKind, SessionStatus, StateComponents, type ClientPluginCustomization, type Customization, type PendingMessage, type RootState, type SessionInputAnswer, type SessionMeta, type ToolCallResult, type Turn, type PolicyState } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/sessionState";
 export declare enum AgentHostIpcChannels {
     /** Channel for the agent host service on the main-process side */
     AgentHost = "agentHost",
@@ -25,8 +28,8 @@ export declare enum AgentHostIpcChannels {
 }
 /** Configuration key that controls whether the local agent host process is spawned. */
 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";
+/** Whether the local/process-backed agent host is enabled in this runtime. */
+export declare function isAgentHostEnabled(configurationService: IConfigurationService): boolean;
 /** Configuration key that controls whether AHP JSONL logs are written for agent host transports. */
 export declare const AgentHostAhpJsonlLoggingSettingId = "chat.agentHost.ahpJsonlLoggingEnabled";
 /** Configuration key that controls whether Agent Host uses its terminal tool override for Copilot SDK sessions. */
@@ -51,6 +54,32 @@ export declare const AgentHostClaudeAgentSdkPathSettingId = "chat.agentHost.clau
  * by developers as an override.
  */
 export declare const AgentHostClaudeSdkPathEnvVar = "VSCODE_AGENT_HOST_CLAUDE_SDK_PATH";
+/**
+ * Absolute path to a locally-installed `codex` binary. When non-empty, the
+ * Codex agent provider is registered inside the agent host. Empty (the
+ * default) disables the provider entirely.
+ */
+export declare const AgentHostCodexAgentBinaryPathSettingId = "chat.agentHost.codexAgent.path";
+/**
+ * Optional override for `$CODEX_HOME`. When set, the codex app-server child
+ * process inherits this value, controlling where rollouts and config live.
+ */
+export declare const AgentHostCodexAgentCodexHomeSettingId = "chat.agentHost.codexAgent.codexHome";
+/**
+ * Additional command-line arguments passed to `codex app-server`. Mainly for
+ * debugging (e.g. `--log-level=debug`).
+ */
+export declare const AgentHostCodexAgentBinaryArgsSettingId = "chat.agentHost.codexAgent.binaryArgs";
+/**
+ * Environment variable the agent host process reads to locate the codex
+ * binary. Forwarded by the starters from
+ * {@link AgentHostCodexAgentBinaryPathSettingId}.
+ */
+export declare const AgentHostCodexAgentBinaryPathEnvVar = "VSCODE_AGENT_HOST_CODEX_APP_SERVER_PATH";
+/** Forwarded `$CODEX_HOME`. */
+export declare const AgentHostCodexAgentCodexHomeEnvVar = "CODEX_HOME";
+/** Forwarded extra args for `codex app-server` (JSON-encoded string[]). */
+export declare const AgentHostCodexAgentBinaryArgsEnvVar = "VSCODE_AGENT_HOST_CODEX_APP_SERVER_ARGS";
 /** Master toggle for agent-host OTel. Explicit opt-in; other settings imply this when set. */
 export declare const AgentHostOTelEnabledSettingId = "chat.agentHost.otel.enabled";
 /** Exporter type for the SDK's OTel pipeline. One of: `otlp-http`, `otlp-grpc`, `console`, `file`. */
@@ -154,11 +183,25 @@ export interface IAgentSessionMetadata {
     /** Human-readable description of what the session is currently doing. */
     readonly activity?: string;
     readonly model?: ModelSelection;
+    /**
+     * Selected custom agent for this session. Absent (`undefined`) means no
+     * custom agent is selected — the session uses the provider's default
+     * behavior.
+     */
+    readonly agent?: AgentSelection;
     readonly workingDirectory?: URI;
     readonly customizationDirectory?: URI;
     readonly isRead?: boolean;
     readonly isArchived?: boolean;
-    readonly diffs?: readonly FileEdit[];
+    /**
+     * Catalogue of changesets the agent can produce for this session — the
+     * {@link ChangesetSummary | catalogue} that travels on
+     * `SessionSummary.changesets`. Lightweight summary entries (id / label /
+     * URI template / aggregate counts) without per-file detail; clients
+     * subscribe to a specific expanded changeset URI when they need the full
+     * file list.
+     */
+    readonly changesets?: readonly ChangesetSummary[];
     /**
      * Side-channel metadata mirroring {@link SessionState._meta}, propagated
      * to clients via per-session state subscriptions.
@@ -215,9 +258,21 @@ export interface AuthenticateParams {
      * {@link IAuthorizationProtectedResourceMetadata} that this token targets.
      */
     readonly resource: string;
+    /**
+     * Scopes that were used to acquire the token. Omitted for legacy clients
+     * that can only identify tokens by protected resource.
+     */
+    readonly scopes?: readonly string[];
     /** The bearer token value (RFC 6750). */
     readonly token: string;
 }
+/** Request for a previously accepted bearer token. */
+export interface IAgentHostAuthTokenRequest {
+    /** Protected resource identifier from {@link ProtectedResourceMetadata.resource}. */
+    readonly resource: string;
+    /** Required token scopes, when the caller needs a scope-specific token. */
+    readonly scopes?: readonly string[];
+}
 /**
  * Result of the `authenticate` command.
  */
@@ -234,9 +289,27 @@ export interface AuthenticateResult {
  * token down separate code paths.
  */
 export declare const GITHUB_COPILOT_PROTECTED_RESOURCE: ProtectedResourceMetadata;
+/**
+ * Canonical {@link ProtectedResourceMetadata} for GitHub repository write
+ * operations (e.g. creating a pull request). Distinct from
+ * {@link GITHUB_COPILOT_PROTECTED_RESOURCE} so that the broader `repo`
+ * scope is only requested when a session actually needs it (e.g. when a
+ * changeset operation handler throws `AHP_AUTH_REQUIRED` with this
+ * resource), rather than at session create for every agent.
+ *
+ * `required: false` reflects that the resource is only needed on demand —
+ * agents do not have to advertise it eagerly. The workbench-side auth
+ * contributor resolves it lazily in response to operation invocations.
+ */
+export declare const GITHUB_REPO_PROTECTED_RESOURCE: ProtectedResourceMetadata;
 export interface IAgentCreateSessionConfig {
     readonly provider?: AgentProvider;
     readonly model?: ModelSelection;
+    /**
+     * Initial custom agent selection for the new session. Omit to start with
+     * no custom agent selected (provider default behavior).
+     */
+    readonly agent?: AgentSelection;
     readonly session?: URI;
     readonly workingDirectory?: URI;
     readonly config?: Record<string, unknown>;
@@ -330,7 +403,7 @@ export interface IAgentToolPendingConfirmationSignal {
     /** 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";
+    readonly permissionKind?: "shell" | "write" | "mcp" | "read" | "url" | "custom-tool" | "hook" | "memory" | "extension-management" | "extension-permission-access";
     /** Host-only auto-approval path target (not part of the dispatched action). */
     readonly permissionPath?: string;
     /**
@@ -442,6 +515,13 @@ export interface IAgent {
     abortSession(session: URI): Promise<void>;
     /** Change the model for an existing session. */
     changeModel(session: URI, model: ModelSelection): Promise<void>;
+    /**
+     * Change (or clear) the selected custom agent for an existing session.
+     * Passing `undefined` clears the selection and resets the session to no
+     * selected custom agent (provider default behavior). Optional so non-
+     * Copilot agents can opt out.
+     */
+    changeAgent?(session: URI, agent: AgentSelection | undefined): 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. */
@@ -463,16 +543,18 @@ export interface IAgent {
      */
     readonly onDidCustomizationsChange?: Event<void>;
     /**
-     * Returns the host-owned customization refs this agent currently exposes.
+     * Returns the host-owned customizations this agent currently exposes.
      *
      * Used to publish baseline customization metadata on {@link AgentInfo}.
+     * Always container customizations ({@link PluginCustomization} or
+     * {@link DirectoryCustomization}).
      */
-    getCustomizations?(): readonly CustomizationRef[];
+    getCustomizations?(): readonly Customization[];
     /**
      * Returns the effective customization list for a session, including
      * source, enablement, and loading/error status.
      */
-    getSessionCustomizations?(session: URI): Promise<readonly SessionCustomization[]>;
+    getSessionCustomizations?(session: URI): Promise<readonly Customization[]>;
     /**
      * Authenticate for a specific resource. Returns true if accepted.
      * The `resource` matches {@link IAuthorizationProtectedResourceMetadata.resource}.
@@ -492,13 +574,13 @@ export interface IAgent {
      */
     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
-     * local plugin directories.
+     * Receives client-provided customization refs for a session and syncs them
+     * (e.g. copies plugin files to local storage). The agent publishes
+     * customization state actions as the sync progresses.
      *
      * The agent MAY defer a client restart until all active sessions are idle.
      */
-    setClientCustomizations(clientId: string, customizations: CustomizationRef[], progress?: (results: ISyncedCustomization[]) => void): Promise<ISyncedCustomization[]>;
+    setClientCustomizations(session: URI, clientId: string, customizations: ClientPluginCustomization[]): Promise<ISyncedCustomization[]>;
     /**
      * Receives client-provided tool definitions to make available in a
      * specific session. The agent registers these as custom tools so the
@@ -524,8 +606,10 @@ export interface IAgent {
     /**
      * Notifies the agent that a customization has been toggled on or off.
      * The agent MAY restart its client before the next message is sent.
+     *
+     * @param id The opaque session-unique customization id.
      */
-    setCustomizationEnabled(uri: string, enabled: boolean): void;
+    setCustomizationEnabled(id: string, enabled: boolean): void;
     /** Gracefully shut down all sessions. */
     shutdown(): Promise<void>;
     /** Dispose this provider and all its resources. */
@@ -539,12 +623,31 @@ export interface IAgent {
  * management and optimistic write-ahead on top.
  */
 export interface IAgentConnection {
-    readonly _serviceBrand: undefined;
     readonly clientId: string;
     readonly rootState: IAgentSubscription<RootState>;
-    getSubscription<T extends StateComponents>(kind: T, resource: URI): IReference<IAgentSubscription<ComponentToState[T]>>;
+    /**
+     * Acquire a refcounted subscription to `resource`. `owner` names the
+     * caller holding the reference so inspection surfaces can attribute who
+     * is retaining a subscription; use a stable identifier such as the
+     * acquiring class name.
+     */
+    getSubscription<T extends StateComponents>(kind: T, resource: URI, owner: string): IReference<IAgentSubscription<ComponentToState[T]>>;
     getSubscriptionUnmanaged<T extends StateComponents>(kind: T, resource: URI): IAgentSubscription<ComponentToState[T]> | undefined;
-    dispatch(action: SessionAction | TerminalAction | IRootConfigChangedAction): void;
+    /**
+     * Read-only descriptors of every active resource subscription on this
+     * connection, for inspection/debug surfaces. Excludes the always-live
+     * {@link rootState}.
+     */
+    getActiveSubscriptions(): readonly IActiveSubscriptionInfo[];
+    /**
+     * Dispatch a client-originated action. `channel` is the protocol URI
+     * string identifying the channel the action targets (a session URI for
+     * session actions, terminal URI for terminal actions, or
+     * `ROOT_STATE_URI` for root-config actions). Strings are used rather
+     * than {@link URI} objects so authority-less scheme URIs like
+     * `ahp-root://` survive the wire format without normalization.
+     */
+    dispatch(channel: string, action: SessionAction | TerminalAction | IRootConfigChangedAction): void;
     readonly onDidNotification: Event<INotification>;
     readonly onDidAction: Event<ActionEnvelope>;
     authenticate(params: AuthenticateParams): Promise<AuthenticateResult>;
@@ -562,10 +665,23 @@ export interface IAgentConnection {
     disposeSession(session: URI): Promise<void>;
     createTerminal(params: CreateTerminalParams): Promise<void>;
     disposeTerminal(terminal: URI): Promise<void>;
+    invokeChangesetOperation(params: InvokeChangesetOperationParams): Promise<InvokeChangesetOperationResult>;
     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>;
+    resourceResolve(params: ResourceResolveParams): Promise<ResourceResolveResult>;
+    resourceMkdir(params: ResourceMkdirParams): Promise<ResourceMkdirResult>;
+    createResourceWatch(params: CreateResourceWatchParams): Promise<CreateResourceWatchResult>;
+    /**
+     * Convenience method that bundles
+     * {@link createResourceWatch} + {@link subscribe} + a typed
+     * {@link IFileChange}[] event stream, so consumers (notably
+     * `AHPFileSystemProvider.watch`) can drive a watcher without
+     * understanding the underlying channel protocol. Disposing the
+     * returned handle unsubscribes.
+     */
+    watchResource(params: CreateResourceWatchParams): Promise<IRemoteWatchHandle>;
 }

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

@@ -1,4 +1,5 @@
 
+import { isWeb } from '@codingame/monaco-vscode-api/vscode/vs/base/common/platform';
 import { URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
 
 var AgentHostIpcChannels;
@@ -9,10 +10,15 @@ var AgentHostIpcChannels;
     AgentHostIpcChannels["RemoteProxy"] = "agentHostProxy";
 })(AgentHostIpcChannels || (AgentHostIpcChannels = {}));
 const AgentHostEnabledSettingId = "chat.agentHost.enabled";
-const AgentHostIpcLoggingSettingId = "chat.agentHost.ipcLoggingEnabled";
+function isAgentHostEnabled(configurationService) {
+    return !isWeb && !!configurationService.getValue(AgentHostEnabledSettingId);
+}
 const AgentHostAhpJsonlLoggingSettingId = "chat.agentHost.ahpJsonlLoggingEnabled";
 const AgentHostCustomTerminalToolEnabledSettingId = "chat.agentHost.customTerminalTool.enabled";
 const AgentHostClaudeAgentSdkPathSettingId = "chat.agentHost.claudeAgent.path";
+const AgentHostCodexAgentBinaryPathSettingId = "chat.agentHost.codexAgent.path";
+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 AgentHostOTelOtlpEndpointSettingId = "chat.agentHost.otel.otlpEndpoint";
@@ -40,4 +46,4 @@ var AgentSession;
     AgentSession.provider = provider;
 })(AgentSession || (AgentSession = {}));
 
-export { AgentHostAhpJsonlLoggingSettingId, AgentHostClaudeAgentSdkPathSettingId, AgentHostCustomTerminalToolEnabledSettingId, AgentHostEnabledSettingId, AgentHostIpcChannels, AgentHostIpcLoggingSettingId, AgentHostOTelCaptureContentSettingId, AgentHostOTelDbSpanExporterEnabledSettingId, AgentHostOTelEnabledSettingId, AgentHostOTelExporterTypeSettingId, AgentHostOTelOtlpEndpointSettingId, AgentHostOTelOutfileSettingId, AgentSession };
+export { AgentHostAhpJsonlLoggingSettingId, AgentHostClaudeAgentSdkPathSettingId, AgentHostCodexAgentBinaryArgsSettingId, AgentHostCodexAgentBinaryPathSettingId, AgentHostCodexAgentCodexHomeSettingId, AgentHostCustomTerminalToolEnabledSettingId, AgentHostEnabledSettingId, AgentHostIpcChannels, AgentHostOTelCaptureContentSettingId, AgentHostOTelDbSpanExporterEnabledSettingId, AgentHostOTelEnabledSettingId, AgentHostOTelExporterTypeSettingId, AgentHostOTelOtlpEndpointSettingId, AgentHostOTelOutfileSettingId, AgentSession, isAgentHostEnabled };

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

@@ -22,14 +22,18 @@ export declare class AhpJsonlLogger extends Disposable {
     private _currentSize;
     private _segment;
     private _queue;
+    private _pending;
+    private _drainScheduled;
     private _folderCreated;
     constructor(_options: IAhpJsonlLoggerOptions, _fileService: IFileService, _logService: ILogService);
     get resource(): URI;
     log(message: object, dir: AhpLogDirection, byteLength?: number): void;
     flush(): Promise<void>;
-    private _appendLine;
+    private _scheduleDrain;
+    private _drainPending;
     private _rotate;
     private _resourceForSegment;
     private _getFileSize;
 }
 export declare function getAhpLogByteLength(text: string): number;
+export declare function stringifyAhpLogEntry(value: unknown): string;

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

@@ -2,13 +2,18 @@
 import { __decorate, __param } from '@codingame/monaco-vscode-api/external/tslib/tslib.es6';
 import { VSBuffer } from '@codingame/monaco-vscode-api/vscode/vs/base/common/buffer';
 import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { MarshalledId } from '@codingame/monaco-vscode-api/vscode/vs/base/common/marshallingIds';
 import { joinPath } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
+import { isUriComponents, URI } from '@codingame/monaco-vscode-api/vscode/vs/base/common/uri';
 import { IFileService } from '@codingame/monaco-vscode-api/vscode/vs/platform/files/common/files.service';
 import { ILogService } from '@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service';
 
 const AHP_LOG_DIR = "ahp";
 const DEFAULT_MAX_FILE_SIZE_BYTES = 75 * 1024 * 1024;
 const DEFAULT_MAX_FILES = 5;
+const MAX_BATCH_BYTES = 1024 * 1024;
+const MAX_LOG_LINE_LENGTH = 1024 * 1024;
+const MAX_LOGGED_STRING_LENGTH = 16 * 1024;
 let AhpJsonlLogger = class AhpJsonlLogger extends Disposable {
     constructor(_options, _fileService, _logService) {
         super();
@@ -18,6 +23,8 @@ let AhpJsonlLogger = class AhpJsonlLogger extends Disposable {
         this._currentSize = 0;
         this._segment = 0;
         this._queue = Promise.resolve();
+        this._pending = [];
+        this._drainScheduled = false;
         this._directory = joinPath(this._options.logsHome, AHP_LOG_DIR);
         const safeConnectionId = sanitizeFilePart(this._options.connectionId).slice(0, 64);
         this._baseName = `ahp-${toFileTimestamp(( new Date()))}-${safeConnectionId}.jsonl`;
@@ -29,28 +36,47 @@ let AhpJsonlLogger = class AhpJsonlLogger extends Disposable {
         return this._currentFile;
     }
     log(message, dir, byteLength) {
+        const meta = {
+            ts: ( new Date()).toISOString(),
+            dir,
+            connectionId: this._options.connectionId,
+            transport: this._options.transport,
+            ...(typeof byteLength === "number" ? {
+                byteLength
+            } : {})
+        };
         const entry = {
             ...message,
-            _ahpLog: {
-                ts: ( new Date()).toISOString(),
-                dir,
-                connectionId: this._options.connectionId,
-                transport: this._options.transport,
-                ...(typeof byteLength === "number" ? {
-                    byteLength
-                } : {})
-            }
+            _ahpLog: meta
         };
-        const line = `${JSON.stringify(entry)}\n`;
-        const buffer = VSBuffer.fromString(line);
-        this._queue = this._queue.then(() => this._appendLine(buffer)).catch(error => {
-            this._logService.error("[AHPLog] Failed to write transport log", error);
-        });
+        let body = stringifyAhpLogEntry(entry);
+        if (body.length > MAX_LOG_LINE_LENGTH) {
+            meta.truncated = true;
+            body = stringifyAhpLogEntryTruncated(entry, MAX_LOGGED_STRING_LENGTH);
+        }
+        const line = `${body}\n`;
+        this._pending.push(VSBuffer.fromString(line));
+        this._scheduleDrain();
     }
     async flush() {
         await this._queue;
     }
-    async _appendLine(buffer) {
+    _scheduleDrain() {
+        if (this._drainScheduled) {
+            return;
+        }
+        this._drainScheduled = true;
+        this._queue = this._queue.then(() => this._drainPending()).catch(error => {
+            this._logService.error("[AHPLog] Failed to write transport log", error);
+        });
+    }
+    async _drainPending() {
+        this._drainScheduled = false;
+        if (this._pending.length === 0) {
+            return;
+        }
+        const buffers = this._pending;
+        this._pending = [];
         if (!this._folderCreated) {
             this._folderCreated = this._fileService.createFolder(this._directory);
         }
@@ -58,13 +84,32 @@ let AhpJsonlLogger = class AhpJsonlLogger extends Disposable {
         if (this._currentSize === 0) {
             this._currentSize = await this._getFileSize(this._currentFile);
         }
-        if (this._currentSize > 0 && this._currentSize + buffer.byteLength > this._maxFileSizeBytes) {
-            await this._rotate();
+        let chunk = [];
+        let chunkSize = 0;
+        const flushChunk = async () => {
+            if (chunk.length === 0) {
+                return;
+            }
+            const combined = chunk.length === 1 ? chunk[0] : VSBuffer.concat(chunk, chunkSize);
+            await this._fileService.writeFile(this._currentFile, combined, {
+                append: true
+            });
+            this._currentSize += combined.byteLength;
+            chunk = [];
+            chunkSize = 0;
+        };
+        for (const buffer of buffers) {
+            const totalInFile = this._currentSize + chunkSize;
+            if (totalInFile > 0 && totalInFile + buffer.byteLength > this._maxFileSizeBytes) {
+                await flushChunk();
+                await this._rotate();
+            } else if (chunkSize > 0 && chunkSize + buffer.byteLength > MAX_BATCH_BYTES) {
+                await flushChunk();
+            }
+            chunk.push(buffer);
+            chunkSize += buffer.byteLength;
         }
-        await this._fileService.writeFile(this._currentFile, buffer, {
-            append: true
-        });
-        this._currentSize += buffer.byteLength;
+        await flushChunk();
     }
     async _rotate() {
         this._segment++;
@@ -96,6 +141,24 @@ AhpJsonlLogger = ( __decorate([( __param(1, IFileService)), ( __param(2, ILogSer
 function getAhpLogByteLength(text) {
     return VSBuffer.fromString(text).byteLength;
 }
+function stringifyAhpLogEntry(value) {
+    return JSON.stringify(value, _ahpReplacer);
+}
+function stringifyAhpLogEntryTruncated(value, maxStringLength) {
+    return JSON.stringify(value, function(key, val) {
+        const revived = _ahpReplacer.call(this, key, val);
+        if (typeof revived === "string" && revived.length > maxStringLength) {
+            return `${revived.slice(0, maxStringLength)}…[${revived.length - maxStringLength} more chars elided]`;
+        }
+        return revived;
+    });
+}
+function _ahpReplacer(_key, value) {
+    if (value && typeof value === "object" && value.$mid === MarshalledId.Uri && isUriComponents(value)) {
+        return ( URI.revive(value).toString());
+    }
+    return value;
+}
 function toFileTimestamp(date) {
     return date.toISOString().replace(/[:.]/g, "-");
 }
@@ -103,4 +166,4 @@ function sanitizeFilePart(value) {
     return value.replace(/[\\/:\*\?"<>\|\s]+/g, "-").replace(/^-+|-+$/g, "") || "connection";
 }
 
-export { AhpJsonlLogger, getAhpLogByteLength };
+export { AhpJsonlLogger, getAhpLogByteLength, stringifyAhpLogEntry };

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

@@ -0,0 +1,36 @@
+import type { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
+import { type AgentCustomization, type Customization } from "@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/state/protocol/state";
+/**
+ * Computes the effective set of selectable custom agents for a session.
+ *
+ * Custom agents live as {@link CustomizationType.Agent | `Agent`} entries
+ * in each container customization's {@link Customization.children | `children`}
+ * array. Only the agent host populates `children` (after parsing the
+ * container). Disabled containers are skipped; containers with an absent
+ * `children` field are treated as "unknown" (e.g. the host has not finished
+ * parsing yet) and skipped, while an empty array means "no children
+ * contributed" and is respected.
+ *
+ * The picker is keyed on the agent's stable {@link AgentCustomization.uri};
+ * duplicates within the session's customization list are coalesced.
+ */
+export declare function getEffectiveAgents(sessionCustomizations: readonly Customization[] | undefined): readonly AgentCustomization[];
+/**
+ * Storage key used by the custom-agent pickers to remember the user's last
+ * selection per session-resource scheme. Shared between the Agents Window
+ * picker and the workbench chat-editor picker so the two surfaces agree on
+ * the default for new (untitled) sessions.
+ */
+export declare function agentHostAgentPickerStorageKey(resourceScheme: string): string;
+/**
+ * Resolves the agent that should be shown for a session:
+ * - If the session has a current selection and it exists in the effective list, use it.
+ * - Else if a stored agent URI matches an entry in the list, use that entry.
+ * - Else `undefined` (the default "Agent" placeholder row).
+ *
+ * `sessionAgentUri` accepts either a platform {@link URI} instance or a raw
+ * URI string. The agent-host protocol
+ * {@link import('./state/protocol/state.js').AgentSelection} URI field and the
+ * sessions-layer `ISessionAgentRef` both provide URI strings.
+ */
+export declare function resolveAgentHostAgent(agents: readonly AgentCustomization[], sessionAgentUri: URI | string | undefined, storedAgentUri: string | undefined): AgentCustomization | undefined;