@codingame/monaco-vscode-chat-service-override 37.2.0 → 37.3.0

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

@@ -1,161 +0,0 @@
-
-import { AgentNetworkDomainSettingId } from '../../networkFilter/common/settings.js';
-import { normalizeDomainPattern } from '../../networkFilter/common/domainMatcher.js';
-import { buildManagedFamilyRule, ManagedRuleFamily, buildManagedRule } from './agentHostManagedRules.js';
-import { inspectValue, getGlobalConfigurationValue } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostConfigurationSync';
-import { GLOBAL_AUTO_APPROVE_SETTING_ID, ELIGIBLE_FOR_AUTO_APPROVAL_SETTING_ID, TERMINAL_AUTO_APPROVE_ENABLED_SETTING_ID, TERMINAL_AUTO_APPROVE_SETTING_ID } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostSchema';
-
-const AgentHostMapLegacySettingsToManagedSettingsSettingId = "chat.agentHost.copilot.mapLegacySettingsToManagedSettings";
-function managedPermissionsSetting(settingId, sources, transform) {
-    return {
-        settingId,
-        contribute: configurationService => {
-            const configuration = inspectValue(configurationService, settingId);
-            if (configuration === undefined) {
-                return undefined;
-            }
-            const [value, source] = configuration;
-            if (sources === "policyOnly" && source !== "policyValue") {
-                return undefined;
-            }
-            return transform(value);
-        }
-    };
-}
-function managedPermissionsCompositeSetting(settingId, additionalSettingIds, contribute) {
-    return {
-        settingId,
-        additionalSettingIds,
-        contribute
-    };
-}
-function contributeNetworkDomainRules(configurationService) {
-    if (getGlobalConfigurationValue(configurationService, AgentNetworkDomainSettingId.NetworkFilter) !== true) {
-        return undefined;
-    }
-    const allowed = getGlobalConfigurationValue(configurationService, AgentNetworkDomainSettingId.AllowedNetworkDomains) ?? [];
-    const denied = getGlobalConfigurationValue(configurationService, AgentNetworkDomainSettingId.DeniedNetworkDomains) ?? [];
-    if (allowed.length === 0 && denied.length === 0) {
-        return {
-            deny: [buildManagedFamilyRule(ManagedRuleFamily.Domain)]
-        };
-    }
-    const deny = [];
-    for (const pattern of denied) {
-        if (typeof pattern !== "string") {
-            continue;
-        }
-        const domain = normalizeDomainPattern(pattern);
-        if (!domain) {
-            continue;
-        }
-        const rule = domain === "*" ? buildManagedFamilyRule(ManagedRuleFamily.Domain) : buildManagedRule(ManagedRuleFamily.Domain, domain);
-        if (rule) {
-            deny.push(rule);
-        }
-    }
-    return deny.length > 0 ? {
-        deny
-    } : undefined;
-}
-function contributeTerminalDenialRules(rules) {
-    if (!rules || typeof rules !== "object") {
-        return undefined;
-    }
-    const ask = [];
-    for (const [command, value] of Object.entries(rules)) {
-        if (!isSubCommandDenial(value) || !isLiteralCommandKey(command)) {
-            continue;
-        }
-        const rule = buildManagedRule(ManagedRuleFamily.Shell, command);
-        if (rule) {
-            ask.push(rule);
-        }
-    }
-    return ask.length > 0 ? {
-        ask
-    } : undefined;
-}
-function isSubCommandDenial(value) {
-    if (value === false) {
-        return true;
-    }
-    return typeof value === "object" && value !== null && value.approve === false && value.matchCommandLine !== true;
-}
-const AUTO_APPROVE_REGEX_KEY = /^\/.+\/[dgimsuvy]*$/;
-function isLiteralCommandKey(command) {
-    return !AUTO_APPROVE_REGEX_KEY.test(command) && !command.includes("*");
-}
-function contributeEligibleForAutoApprovalRestriction(value) {
-    if (!value || typeof value !== "object" || Array.isArray(value)) {
-        return undefined;
-    }
-    if (( Object.values(value)).every(eligible => eligible === true)) {
-        return undefined;
-    }
-    return {
-        disableBypassPermissionsMode: "disable"
-    };
-}
-const managedPermissionsSettings = [
-    managedPermissionsSetting(GLOBAL_AUTO_APPROVE_SETTING_ID, "policyOnly", value => value === false ? {
-        disableBypassPermissionsMode: "disable"
-    } : undefined),
-    managedPermissionsSetting(
-        ELIGIBLE_FOR_AUTO_APPROVAL_SETTING_ID,
-        "policyOnly",
-        contributeEligibleForAutoApprovalRestriction
-    ),
-    managedPermissionsSetting(
-        TERMINAL_AUTO_APPROVE_ENABLED_SETTING_ID,
-        "anyGlobal",
-        value => value === false ? {
-            ask: [buildManagedFamilyRule(ManagedRuleFamily.Shell)]
-        } : undefined
-    ),
-    managedPermissionsCompositeSetting(AgentNetworkDomainSettingId.NetworkFilter, [
-        AgentNetworkDomainSettingId.AllowedNetworkDomains,
-        AgentNetworkDomainSettingId.DeniedNetworkDomains
-    ], contributeNetworkDomainRules),
-    managedPermissionsSetting(
-        TERMINAL_AUTO_APPROVE_SETTING_ID,
-        "anyGlobal",
-        contributeTerminalDenialRules
-    )
-];
-const managedPermissionsConfigurationIds = [
-    AgentHostMapLegacySettingsToManagedSettingsSettingId,
-    ...managedPermissionsSettings.flatMap(mapping => [mapping.settingId, ...(mapping.additionalSettingIds ?? [])])
-];
-function resolveManagedSettingsPermissions(configurationService) {
-    if (getGlobalConfigurationValue(configurationService, AgentHostMapLegacySettingsToManagedSettingsSettingId) !== true) {
-        return {};
-    }
-    const deny = ( new Set());
-    const ask = ( new Set());
-    let disableBypassPermissionsMode;
-    for (const mapping of managedPermissionsSettings) {
-        const contribution = mapping.contribute(configurationService);
-        if (!contribution) {
-            continue;
-        }
-        if (contribution.disableBypassPermissionsMode) {
-            disableBypassPermissionsMode = contribution.disableBypassPermissionsMode;
-        }
-        contribution.deny?.forEach(rule => deny.add(rule));
-        contribution.ask?.forEach(rule => ask.add(rule));
-    }
-    const permissions = {};
-    if (disableBypassPermissionsMode) {
-        permissions.disableBypassPermissionsMode = disableBypassPermissionsMode;
-    }
-    if (deny.size > 0) {
-        permissions.deny = [...deny];
-    }
-    if (ask.size > 0) {
-        permissions.ask = [...ask];
-    }
-    return permissions;
-}
-
-export { AgentHostMapLegacySettingsToManagedSettingsSettingId, managedPermissionsConfigurationIds, resolveManagedSettingsPermissions };

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

@@ -1,16 +0,0 @@
-import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
-/**
- * Returns `true` when a session spans more than one effective working
- * directory (a *multi-root* session), and `false` otherwise — including when
- * the session has no working directories or exactly one.
- *
- * Callers pass the ordered set returned by
- * `IAgentConfigurationService.getEffectiveWorkingDirectories(session)` (index 0
- * is the primary). Multi-root change-reporting behavior is gated on this
- * predicate, so single-root and empty sessions keep their existing behavior.
- */
-export declare function isMultiRootSession(workingDirectories: readonly string[] | undefined): boolean;
-/**
- * Finds the deepest working directory that contains `resource`.
- */
-export declare function findDeepestContainingWorkingDirectory(resource: URI, workingDirectories: readonly URI[]): URI | undefined;

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

@@ -1,14 +0,0 @@
-
-import { extUriBiasedIgnorePathCase } from '@codingame/monaco-vscode-api/vscode/vs/base/common/resources';
-
-function findDeepestContainingWorkingDirectory(resource, workingDirectories) {
-    let deepestMatch;
-    for (const workingDirectory of workingDirectories) {
-        if (extUriBiasedIgnorePathCase.isEqualOrParent(resource, workingDirectory) && (!deepestMatch || workingDirectory.path.length > deepestMatch.path.length)) {
-            deepestMatch = workingDirectory;
-        }
-    }
-    return deepestMatch;
-}
-
-export { findDeepestContainingWorkingDirectory };

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

@@ -1,261 +0,0 @@
-import { GitHubActor, PullRequestCheck, PullRequestChecks, PullRequestSnapshot } from "@codingame/monaco-vscode-api/vscode/vs/platform/github/common/githubPullRequestService";
-export declare const AgentMergeConfigKey: {
-    readonly Enabled: "agentMerge.enabled";
-    readonly AddressReviews: "agentMerge.addressReviews";
-    readonly FixCI: "agentMerge.fixCI";
-    readonly ResolveConflicts: "agentMerge.resolveConflicts";
-    readonly MergePullRequest: "agentMerge.mergePullRequest";
-    readonly MergeMethod: "agentMerge.mergeMethod";
-    readonly ReplyAttribution: "agentMerge.replyAttribution";
-};
-export declare const AgentMergeSettingId: {
-    readonly Enabled: "chat.agentMerge.enabled";
-    readonly AddressReviews: "chat.agentMerge.addressReviews";
-    readonly FixCI: "chat.agentMerge.fixCI";
-    readonly ResolveConflicts: "chat.agentMerge.resolveConflicts";
-    readonly MergePullRequest: "chat.agentMerge.mergePullRequest";
-    readonly MergeMethod: "chat.agentMerge.mergeMethod";
-    readonly ReplyAttribution: "chat.agentMerge.replyAttribution";
-};
-/**
- * Settings-editor tag carried by every Agent Merge setting, so the UI can open
- * settings filtered to exactly this group with `@tag:agentMerge`.
- */
-export declare const AGENT_MERGE_SETTING_TAG = "agentMerge";
-/**
- * Work the agent itself can be asked to perform. Merging is deliberately absent:
- * it is executed by the host, never delegated to a model.
- */
-export type AgentMergeRepairAction = "addressReviews" | "fixCI" | "resolveConflicts";
-/** A user-authorizable Agent Merge action, including the host-executed merge. */
-export type AgentMergeAction = AgentMergeRepairAction | "mergePullRequest";
-export type AgentMergeMethod = "auto" | "squash" | "merge" | "rebase";
-/**
- * When Agent Merge may merge the pull request once it is ready.
- *
- * `ifUnchanged` is self-demoting rather than evaluated at merge time: the
- * moment a repair turn lands a commit the session's value is rewritten to
- * `never`, so the chosen value always reflects what will actually happen.
- * Re-selecting `ifUnchanged` starts a fresh baseline from that point.
- */
-export type AgentMergeMergePullRequest = "always" | "ifUnchanged" | "never";
-export declare const agentMergeMergePullRequestValues: readonly AgentMergeMergePullRequest[];
-export interface AgentMergeActions {
-    readonly addressReviews: boolean;
-    readonly fixCI: boolean;
-    readonly resolveConflicts: boolean;
-    readonly mergePullRequest: AgentMergeMergePullRequest;
-}
-export interface AgentMergeConfiguration extends AgentMergeActions {
-    readonly mergeMethod: AgentMergeMethod;
-    readonly replyAttribution: boolean;
-}
-export interface AgentMergeSessionOverrides {
-    readonly addressReviews?: boolean;
-    readonly fixCI?: boolean;
-    readonly resolveConflicts?: boolean;
-    readonly mergePullRequest?: AgentMergeMergePullRequest;
-}
-export interface AgentMergeTarget {
-    readonly branchName: string;
-    readonly pullRequestUrl?: string;
-    readonly enabledAt: string;
-    readonly commentWatermark: string;
-}
-export interface AgentMergeReviewThreadContext {
-    readonly id: string;
-    readonly path?: string;
-    readonly line?: number;
-    /** Authorized comments in the thread, oldest first, so later follow-ups are visible. */
-    readonly comments: readonly AgentMergeFeedbackComment[];
-}
-export interface AgentMergeFeedbackComment {
-    readonly author?: string;
-    readonly body: string;
-}
-export interface AgentMergeInjectedConfiguration {
-    readonly previous: Readonly<Record<string, unknown>>;
-    readonly applied: Readonly<Record<string, unknown>>;
-}
-export interface AgentMergeSessionState {
-    readonly enabled: boolean;
-    readonly overrides?: AgentMergeSessionOverrides;
-    readonly target?: AgentMergeTarget;
-    readonly injectedConfiguration?: AgentMergeInjectedConfiguration;
-    readonly lastPromptFingerprint?: string;
-    readonly lastPromptAt?: string;
-    readonly repeatedPromptCount?: number;
-    readonly totalPromptCount?: number;
-    /**
-     * Local worktree commit observed when the most recent repair turn started.
-     * A different local commit afterwards means that turn produced work, which
-     * is what demotes an `ifUnchanged` session to `never`.
-     *
-     * Deliberately the local commit rather than the pull request's published
-     * head: GitHub reports a push only after some replication delay, and a turn
-     * ends by evaluating immediately, so a published comparison would routinely
-     * read a stale head and merge changes it should have held back.
-     */
-    readonly repairBaseCommit?: string;
-}
-export interface AgentMergeControllerState {
-    readonly target?: AgentMergeTarget;
-    readonly injectedConfiguration?: AgentMergeInjectedConfiguration;
-    readonly lastPromptFingerprint?: string;
-    readonly lastPromptAt?: string;
-    readonly repeatedPromptCount?: number;
-    readonly totalPromptCount?: number;
-    readonly repairBaseCommit?: string;
-}
-export type AgentMergeRequiredChecks = {
-    readonly kind: "ready";
-    readonly failed: readonly PullRequestCheck[];
-    readonly pending: boolean;
-} | {
-    readonly kind: "indeterminate";
-    readonly reason: string;
-};
-export declare const agentMergeRootConfigSchema: import("@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostSchema").ISchema<{
-    "agentMerge.enabled": import("@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostSchema").ISchemaProperty<boolean>;
-    "agentMerge.addressReviews": import("@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostSchema").ISchemaProperty<boolean>;
-    "agentMerge.fixCI": import("@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostSchema").ISchemaProperty<boolean>;
-    "agentMerge.resolveConflicts": import("@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostSchema").ISchemaProperty<boolean>;
-    "agentMerge.mergePullRequest": import("@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostSchema").ISchemaProperty<AgentMergeMergePullRequest>;
-    "agentMerge.mergeMethod": import("@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostSchema").ISchemaProperty<AgentMergeMethod>;
-    "agentMerge.replyAttribution": import("@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostSchema").ISchemaProperty<boolean>;
-}>;
-export declare const defaultAgentMergeConfiguration: AgentMergeConfiguration;
-export type AgentMergeGateResult = {
-    readonly kind: "indeterminate";
-    readonly reason: string;
-    readonly cause: string;
-} | {
-    readonly kind: "terminal";
-} | {
-    readonly kind: "noWork";
-    readonly waitingOnChecks: boolean;
-    readonly fingerprint: string;
-} | {
-    readonly kind: "prompt";
-    readonly actions: readonly AgentMergeRepairAction[];
-    readonly fingerprint: string;
-    readonly context: AgentMergePromptContext;
-} | {
-    readonly kind: "merge";
-    readonly fingerprint: string;
-};
-export interface AgentMergePromptContext {
-    readonly pullRequestUrl: string;
-    readonly title: string;
-    readonly headSha: string;
-    readonly baseRef: string;
-    readonly headRef: string;
-    readonly reviewThreads: readonly AgentMergeReviewThreadContext[];
-    readonly reviewSummaries: readonly AgentMergeFeedbackComment[];
-    readonly newComments: readonly AgentMergeFeedbackComment[];
-    readonly failedChecks: readonly string[];
-    readonly behind: boolean;
-    readonly conflicting: boolean;
-    readonly commentWatermark: string;
-}
-export declare function resolveAgentMergeConfiguration(defaults: AgentMergeConfiguration, overrides: AgentMergeSessionOverrides | undefined): AgentMergeConfiguration;
-/**
- * Maps the configured merge method onto a method the repository actually
- * allows. `auto` prefers squash, then a merge commit, then rebase; an
- * explicitly configured method is only used when the repository permits it.
- */
-export declare function resolveMergeMethod(configured: AgentMergeMethod, allowed: readonly ("MERGE" | "SQUASH" | "REBASE")[]): "MERGE" | "SQUASH" | "REBASE" | undefined;
-/**
- * Why Agent Merge stopped monitoring a session. Keeping both strings together
- * lets the controller log a stable English detail while the transcript shows a
- * localized sentence, without either drifting from the other.
- */
-export interface AgentMergeDisableReason {
-    /** Stable English detail appended to the host log line. */
-    readonly log: string;
-    /** Localized sentence shown to the user in the session transcript. */
-    readonly notice: string;
-}
-/** Every reason the Agent Merge controller can stop monitoring a session on its own. */
-export declare const agentMergeDisableReasons: {
-    readonly sessionArchived: () => AgentMergeDisableReason;
-    readonly branchChanged: (from: string, to: string) => AgentMergeDisableReason;
-    readonly branchChangedWhileRefreshing: () => AgentMergeDisableReason;
-    readonly differentPullRequest: () => AgentMergeDisableReason;
-    readonly invalidPullRequestUrl: () => AgentMergeDisableReason;
-    readonly differentGitHubHost: () => AgentMergeDisableReason;
-    readonly indeterminate: (minutes: number, reason: string) => AgentMergeDisableReason;
-    readonly pullRequestClosed: () => AgentMergeDisableReason;
-    readonly pullRequestAlreadyMerged: (pullRequestNumber: number, pullRequestUrl: string) => AgentMergeDisableReason;
-    readonly repairBudgetExhausted: () => AgentMergeDisableReason;
-    readonly pullRequestMerged: (pullRequestNumber: number, pullRequestUrl: string) => AgentMergeDisableReason;
-};
-/** The transcript notice shown once Agent Merge starts watching a branch. */
-export declare function agentMergeEnabledNotice(target: Pick<AgentMergeTarget, "branchName" | "pullRequestUrl">, configuration: AgentMergeConfiguration): string;
-/**
- * Whether a configuration change was made for one session alone, or to the
- * defaults every session follows.
- */
-export type AgentMergeConfigurationChangeScope = "session" | "global";
-/**
- * The transcript notice shown when effective Agent Merge behavior changes. The
- * scope is named up front because the same change reads very differently
- * depending on whether it was made for this session or for all of them.
- */
-export declare function agentMergeConfigurationChangedNotice(previous: AgentMergeConfiguration, current: AgentMergeConfiguration, scope: AgentMergeConfigurationChangeScope): string | undefined;
-/** The transcript notice shown when the user, rather than the controller, disables Agent Merge. */
-export declare function agentMergeDisabledNotice(): string;
-/**
- * The transcript notice shown when Agent Merge stops merging automatically
- * because its own repair work changed the pull request.
- */
-export declare function agentMergeMergePullRequestDemotedNotice(): string;
-export declare function readAgentMergeSessionState(values: Record<string, unknown> | undefined): AgentMergeSessionState | undefined;
-/**
- * Returns session config values with Agent Merge injected overrides removed,
- * so callers can read the user's own picker selections while merge is active.
- */
-export declare function getNonMergeSessionConfigValues(values: Readonly<Record<string, unknown>> | undefined): Readonly<Record<string, unknown>>;
-export declare function isAgentMergeFeedbackAuthor(actor: GitHubActor | undefined): boolean;
-/**
- * Recorded as the repair baseline when the session worktree cannot be read.
- * No git object id can equal it, so a session that reached this state always
- * counts as changed — see {@link shouldStopMergingAfterAgentChanges}.
- */
-export declare const AGENT_MERGE_UNKNOWN_COMMIT = "unknown";
-/**
- * Whether a session that only authorized merging while the pull request is
- * unchanged must stop merging automatically, because a repair turn produced
- * work since it started.
- *
- * Compares local worktree commits, not the pull request's published head: the
- * commit exists locally the moment the agent makes it, whereas GitHub reports
- * it only after a replication delay that a turn-completion check would race.
- *
- * Fails closed. Once a repair turn has run, a commit that cannot be resolved
- * counts as a change: a missed automatic merge is cheap, whereas merging
- * agent-written changes the user wanted to review first is not.
- *
- * Callers rewrite the chosen value to `never` rather than gating on this, so
- * the value always reflects what will actually happen. Clearing
- * {@link AgentMergeSessionState.repairBaseCommit} at the same time is what lets
- * a later re-selection start from a fresh baseline.
- */
-export declare function shouldStopMergingAfterAgentChanges(configuration: AgentMergeConfiguration, agentMerge: AgentMergeSessionState, currentCommit: string | undefined): boolean;
-export declare function isAgentMergeMergePullRequest(value: unknown): value is AgentMergeMergePullRequest;
-export declare function evaluateAgentMerge(snapshot: PullRequestSnapshot, configuration: AgentMergeConfiguration, commentWatermark: string, deferredCheckIds?: ReadonlySet<string>): AgentMergeGateResult;
-/** Fragments the gate must be able to read before it can decide anything. */
-export declare const agentMergeGateFragments: readonly [
-    "core",
-    "topLevelComments",
-    "submittedReviews",
-    "reviewThreads",
-    "checks",
-    "mergeability"
-];
-/**
- * Returns whether a draft pull request has no pending or failed required checks
- * and no actionable review feedback, or `undefined` while that state is incomplete.
- */
-export declare function isAgentMergePullRequestReadyForReview(snapshot: PullRequestSnapshot, commentWatermark: string): boolean | undefined;
-export declare function classifyAgentMergeRequiredChecks(checks: PullRequestChecks): AgentMergeRequiredChecks;

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

@@ -1,67 +0,0 @@
-
-import { localize } from '@codingame/monaco-vscode-api/vscode/vs/nls';
-import '@codingame/monaco-vscode-api/vscode/vs/base/common/htmlContent';
-import '@codingame/monaco-vscode-api/vscode/vs/base/common/equals';
-import { createSchema, schemaProperty } from '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/agentHostSchema';
-import '@codingame/monaco-vscode-api/vscode/vs/platform/agentHost/common/sessionConfigKeys';
-
-const AgentMergeConfigKey = {
-    Enabled: "agentMerge.enabled",
-    AddressReviews: "agentMerge.addressReviews",
-    FixCI: "agentMerge.fixCI",
-    ResolveConflicts: "agentMerge.resolveConflicts",
-    MergePullRequest: "agentMerge.mergePullRequest",
-    MergeMethod: "agentMerge.mergeMethod",
-    ReplyAttribution: "agentMerge.replyAttribution"
-};
-const AgentMergeSettingId = {
-    Enabled: "chat.agentMerge.enabled",
-    AddressReviews: "chat.agentMerge.addressReviews",
-    FixCI: "chat.agentMerge.fixCI",
-    ResolveConflicts: "chat.agentMerge.resolveConflicts",
-    MergePullRequest: "chat.agentMerge.mergePullRequest",
-    MergeMethod: "chat.agentMerge.mergeMethod",
-    ReplyAttribution: "chat.agentMerge.replyAttribution"
-};
-const AGENT_MERGE_SETTING_TAG = "agentMerge";
-createSchema({
-    [AgentMergeConfigKey.Enabled]: schemaProperty({
-        type: "boolean",
-        title: ( localize(2041, "Agent Merge")),
-        default: false
-    }),
-    [AgentMergeConfigKey.AddressReviews]: schemaProperty({
-        type: "boolean",
-        title: ( localize(2042, "Address Reviews")),
-        default: true
-    }),
-    [AgentMergeConfigKey.FixCI]: schemaProperty({
-        type: "boolean",
-        title: ( localize(2043, "Fix CI Failures")),
-        default: true
-    }),
-    [AgentMergeConfigKey.ResolveConflicts]: schemaProperty({
-        type: "boolean",
-        title: ( localize(2044, "Resolve Conflicts")),
-        default: true
-    }),
-    [AgentMergeConfigKey.MergePullRequest]: schemaProperty({
-        type: "string",
-        title: ( localize(2045, "Merge Pull Request")),
-        enum: ["always", "ifUnchanged", "never"],
-        default: "never"
-    }),
-    [AgentMergeConfigKey.MergeMethod]: schemaProperty({
-        type: "string",
-        title: ( localize(2046, "Merge Method")),
-        enum: ["auto", "squash", "merge", "rebase"],
-        default: "auto"
-    }),
-    [AgentMergeConfigKey.ReplyAttribution]: schemaProperty({
-        type: "boolean",
-        title: ( localize(2047, "Reply Attribution")),
-        default: true
-    })
-});
-
-export { AGENT_MERGE_SETTING_TAG, AgentMergeConfigKey, AgentMergeSettingId };

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

@@ -1,39 +0,0 @@
-import { Disposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
-import { 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";
-export type AhpLogDirection = "c2s" | "s2c";
-export interface IAhpJsonlLoggerOptions {
-    readonly logsHome: URI;
-    readonly connectionId: string;
-    readonly transport: string;
-    readonly maxFileSizeBytes?: number;
-    readonly maxFiles?: number;
-}
-export declare class AhpJsonlLogger extends Disposable {
-    private readonly _options;
-    private readonly _fileService;
-    private readonly _logService;
-    private readonly _directory;
-    private readonly _baseName;
-    private readonly _maxFileSizeBytes;
-    private readonly _maxFiles;
-    private _currentFile;
-    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 _scheduleDrain;
-    private _drainPending;
-    private _rotate;
-    private _resourceForSegment;
-    private _getFileSize;
-}
-export declare function getAhpLogByteLength(text: string): number;
-export declare function stringifyAhpLogEntry(value: unknown): string;