@codingame/monaco-vscode-api 37.6.0 → 38.0.0

package/vscode/src/vs/platform/agentHost/common/meta/vscode/agentUsageMeta.js

@@ -0,0 +1,203 @@
+
+
+function isTokenCount(value) {
+    return typeof value === 'number' && Number.isSafeInteger(value) && value >= 0;
+}
+function readAccountQuotaSnapshot(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        return undefined;
+    }
+    const raw = value;
+    const snapshot = {};
+    if (typeof raw.isUnlimitedEntitlement === 'boolean') {
+        snapshot.isUnlimitedEntitlement = raw.isUnlimitedEntitlement;
+    }
+    if (typeof raw.entitlementRequests === 'number') {
+        snapshot.entitlementRequests = raw.entitlementRequests;
+    }
+    if (typeof raw.usedRequests === 'number') {
+        snapshot.usedRequests = raw.usedRequests;
+    }
+    if (typeof raw.remainingPercentage === 'number') {
+        snapshot.remainingPercentage = raw.remainingPercentage;
+    }
+    if (typeof raw.overage === 'number') {
+        snapshot.overage = raw.overage;
+    }
+    if (typeof raw.overageAllowedWithExhaustedQuota === 'boolean') {
+        snapshot.overageAllowedWithExhaustedQuota = raw.overageAllowedWithExhaustedQuota;
+    }
+    if (typeof raw.resetDate === 'string') {
+        snapshot.resetDate = raw.resetDate;
+    }
+    if (typeof raw.tokenBasedBilling === 'boolean') {
+        snapshot.tokenBasedBilling = raw.tokenBasedBilling;
+    }
+    if (typeof raw.overageEntitlement === 'number') {
+        snapshot.overageEntitlement = raw.overageEntitlement;
+    }
+    return snapshot;
+}
+function readUsageInfoMeta(usage) {
+    const meta = usage?._meta;
+    if (!meta) {
+        return {};
+    }
+    const result = {};
+    if (typeof meta.cost === 'number') {
+        result.cost = meta.cost;
+    }
+    const autoModeResolved = readAutoModeResolvedInfo(meta.autoModeResolved);
+    if (autoModeResolved) {
+        result.autoModeResolved = autoModeResolved;
+    }
+    const copilotUsage = meta.copilotUsage;
+    if (copilotUsage && typeof copilotUsage === 'object' && !Array.isArray(copilotUsage)) {
+        const rawUsage = copilotUsage;
+        const usage = {};
+        if (typeof rawUsage.totalNanoAiu === 'number') {
+            usage.totalNanoAiu = rawUsage.totalNanoAiu;
+        }
+        if (typeof rawUsage.sessionTotalNanoAiu === 'number') {
+            usage.sessionTotalNanoAiu = rawUsage.sessionTotalNanoAiu;
+        }
+        result.copilotUsage = usage;
+    }
+    const quotaSnapshots = meta.quotaSnapshots;
+    if (quotaSnapshots && typeof quotaSnapshots === 'object' && !Array.isArray(quotaSnapshots)) {
+        const snapshots = {};
+        for (const [quotaType, value] of Object.entries(quotaSnapshots)) {
+            snapshots[quotaType] = readAccountQuotaSnapshot(value);
+        }
+        result.quotaSnapshots = snapshots;
+    }
+    const contextAttribution = readContextAttribution(meta.contextAttribution);
+    if (contextAttribution) {
+        result.contextAttribution = contextAttribution;
+    }
+    const turnTokenTotals = readTurnTokenTotals(meta.turnTokenTotals);
+    if (turnTokenTotals) {
+        result.turnTokenTotals = turnTokenTotals;
+    }
+    const directTurnTokenTotals = readTurnTokenTotals(meta.directTurnTokenTotals);
+    if (directTurnTokenTotals) {
+        result.directTurnTokenTotals = directTurnTokenTotals;
+    }
+    const directCopilotUsage = meta.directCopilotUsage;
+    if (directCopilotUsage && typeof directCopilotUsage === 'object' && !Array.isArray(directCopilotUsage)) {
+        const totalNanoAiu = directCopilotUsage.totalNanoAiu;
+        if (typeof totalNanoAiu === 'number') {
+            result.directCopilotUsage = { totalNanoAiu };
+        }
+    }
+    return result;
+}
+function readTurnTokenTotals(value) {
+    if (!Array.isArray(value)) {
+        return undefined;
+    }
+    const totals = [];
+    for (const item of value) {
+        if (!item || typeof item !== 'object' || Array.isArray(item)) {
+            continue;
+        }
+        const raw = item;
+        if (typeof raw.model !== 'string' || !raw.model
+            || !isTokenCount(raw.inputTokens)
+            || !isTokenCount(raw.cachedTokens)
+            || !isTokenCount(raw.outputTokens)) {
+            continue;
+        }
+        totals.push({
+            model: raw.model,
+            inputTokens: raw.inputTokens,
+            cachedTokens: raw.cachedTokens,
+            outputTokens: raw.outputTokens,
+        });
+    }
+    return totals.length > 0 ? totals : undefined;
+}
+function readAutoModeResolvedInfo(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        return undefined;
+    }
+    const raw = value;
+    if (typeof raw.chosenModel !== 'string') {
+        return undefined;
+    }
+    const result = { chosenModel: raw.chosenModel };
+    const reasoningBucket = raw.reasoningBucket;
+    if (reasoningBucket === 'low' || reasoningBucket === 'medium' || reasoningBucket === 'high') {
+        result.reasoningBucket = reasoningBucket;
+    }
+    const categoryScores = raw.categoryScores;
+    if (categoryScores && typeof categoryScores === 'object' && !Array.isArray(categoryScores)) {
+        const scores = {};
+        for (const [category, score] of Object.entries(categoryScores)) {
+            if (typeof score === 'number') {
+                scores[category] = score;
+            }
+        }
+        result.categoryScores = scores;
+    }
+    if (typeof raw.predictedLabel === 'string') {
+        result.predictedLabel = raw.predictedLabel;
+    }
+    if (typeof raw.confidence === 'number') {
+        result.confidence = raw.confidence;
+    }
+    if (Array.isArray(raw.candidateModels) && raw.candidateModels.every(candidate => typeof candidate === 'string')) {
+        result.candidateModels = raw.candidateModels;
+    }
+    if (typeof raw.selectionReason === 'string' && raw.selectionReason.trim()) {
+        result.selectionReason = raw.selectionReason;
+    }
+    return result;
+}
+function readContextAttribution(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        return undefined;
+    }
+    const raw = value;
+    if (typeof raw.totalTokens !== 'number' || !Array.isArray(raw.entries)) {
+        return undefined;
+    }
+    const entries = [];
+    for (const item of raw.entries) {
+        if (!item || typeof item !== 'object' || Array.isArray(item)) {
+            continue;
+        }
+        const entry = item;
+        if (typeof entry.kind !== 'string' || typeof entry.id !== 'string'
+            || typeof entry.label !== 'string' || typeof entry.tokens !== 'number') {
+            continue;
+        }
+        entries.push({
+            kind: entry.kind,
+            id: entry.id,
+            label: entry.label,
+            tokens: entry.tokens,
+            parentId: typeof entry.parentId === 'string' ? entry.parentId : undefined,
+            attributes: entry.attributes && typeof entry.attributes === 'object' && !Array.isArray(entry.attributes)
+                ? filterStringAttributes(entry.attributes)
+                : undefined,
+        });
+    }
+    const compactionsRaw = raw.compactions;
+    const compactions = compactionsRaw && typeof compactionsRaw === 'object' && !Array.isArray(compactionsRaw)
+        && typeof compactionsRaw.count === 'number'
+        ? { count: compactionsRaw.count }
+        : { count: 0 };
+    return { totalTokens: raw.totalTokens, entries, compactions };
+}
+function filterStringAttributes(raw) {
+    const result = {};
+    for (const [key, value] of Object.entries(raw)) {
+        if (typeof value === 'string' || value === undefined) {
+            result[key] = value;
+        }
+    }
+    return result;
+}
+
+export { readUsageInfoMeta };

package/vscode/src/vs/platform/agentHost/common/meta/vscode/agentWorkspaceContinuationMeta.d.ts

@@ -0,0 +1,8 @@
+interface IHasAgentWorkspaceContinuationMeta {
+    readonly _meta?: Record<string, unknown>;
+}
+/** Whether the message is the internal request that resumes a turn after workspace conversion. */
+export declare function isAgentWorkspaceContinuationMessage(source: IHasAgentWorkspaceContinuationMeta): boolean;
+/** Serializes the workspace-continuation marker for the open protocol bag. */
+export declare function toAgentWorkspaceContinuationMessageMeta(): Record<string, unknown>;
+export {};

package/vscode/src/vs/platform/agentHost/common/meta/vscode/browserViewAttachments.d.ts

@@ -0,0 +1,9 @@
+import { type MessageAttachment, type SimpleMessageAttachment } from "../../state/protocol/state.js";
+export declare const BrowserViewAttachmentDisplayKind = "browser";
+export declare const BrowserViewAttachmentMetadataKey = "browserView";
+export interface IBrowserViewAttachmentMetadata {
+    readonly browserId: string;
+    readonly browserUri: string;
+}
+export declare function isBrowserViewAttachment(attachment: MessageAttachment): attachment is SimpleMessageAttachment;
+export declare function getBrowserViewAttachmentMetadata(attachment: MessageAttachment): IBrowserViewAttachmentMetadata | undefined;

package/vscode/src/vs/platform/agentHost/common/meta/{browserViewAttachments.js → vscode/browserViewAttachments.js}

@@ -1,13 +1,13 @@
 
-import { isString } from '../../../../base/common/types.js';
-import '../state/protocol/channels-root/state.js';
-import '../state/protocol/channels-session/state.js';
-import { MessageAttachmentKind } from '../state/protocol/channels-chat/state.js';
-import '../state/protocol/channels-terminal/state.js';
-import '../state/protocol/channels-changeset/state.js';
-import '../state/protocol/channels-resource-watch/state.js';
-import '../state/protocol/channels-automation/state.js';
-import '../state/protocol/channels-automation-run/state.js';
+import { isString } from '../../../../../base/common/types.js';
+import '../../state/protocol/channels-root/state.js';
+import '../../state/protocol/channels-session/state.js';
+import { MessageAttachmentKind } from '../../state/protocol/channels-chat/state.js';
+import '../../state/protocol/channels-terminal/state.js';
+import '../../state/protocol/channels-changeset/state.js';
+import '../../state/protocol/channels-resource-watch/state.js';
+import '../../state/protocol/channels-automation/state.js';
+import '../../state/protocol/channels-automation-run/state.js';
 
 const BrowserViewAttachmentDisplayKind = 'browser';
 const BrowserViewAttachmentMetadataKey = 'browserView';

package/vscode/src/vs/platform/agentHost/common/meta/vscode/codexAccount.d.ts

@@ -0,0 +1,33 @@
+import type { RootState } from "../../state/protocol/state.js";
+export declare const CODEX_ACCOUNT_REFRESH_REQUEST_KEY = "vscode.codexAccount.refreshRequest";
+export declare const CODEX_ACCOUNT_META_KEY = "vscode.codexAccount";
+export declare const CODEX_ACCOUNT_SIGN_IN_REQUEST_KEY = "vscode.codexAccount.signInRequest";
+export declare const CODEX_ACCOUNT_SIGN_OUT_REQUEST_KEY = "vscode.codexAccount.signOutRequest";
+export declare const CODEX_PROFILE_IMAGE_SCHEME = "vscode-codex-profile-image";
+export declare const MAX_CODEX_PROFILE_IMAGE_BYTES: number;
+export interface ICodexProfileImageReference {
+    readonly uri: string;
+    readonly contentType: string;
+    readonly sizeHint: number;
+    readonly nonce: string;
+}
+export interface ICodexAccountRateLimitInfo {
+    readonly usedPercent: number;
+    readonly windowDurationMins?: number;
+    readonly resetsAt?: number;
+}
+export interface ICodexAccountInfo {
+    readonly status: "unknown" | "downloading" | "signedIn" | "signedOut" | "unavailable" | "error";
+    readonly email?: string;
+    readonly planType?: string;
+    readonly profileImage?: ICodexProfileImageReference;
+    readonly requiresOpenaiAuth?: boolean;
+    /** Summary window retained for clients that only display one limit. */
+    readonly rateLimit?: ICodexAccountRateLimitInfo;
+    readonly rateLimits?: readonly ICodexAccountRateLimitInfo[];
+    /** Unix milliseconds at which rate limits were observed, never the publication time. */
+    readonly observedAt?: number;
+    readonly authUrl?: string;
+    readonly authUrlNonce?: string;
+}
+export declare function readCodexAccountInfo(state: RootState | undefined): ICodexAccountInfo;

package/vscode/src/vs/platform/agentHost/common/meta/{codexAccount.js → vscode/codexAccount.js}

@@ -1,6 +1,7 @@
 
-import { URI } from '../../../../base/common/uri.js';
+import { URI } from '../../../../../base/common/uri.js';
 
+const CODEX_ACCOUNT_REFRESH_REQUEST_KEY = "vscode.codexAccount.refreshRequest";
 const CODEX_ACCOUNT_META_KEY = "vscode.codexAccount";
 const CODEX_ACCOUNT_SIGN_IN_REQUEST_KEY = "vscode.codexAccount.signInRequest";
 const CODEX_ACCOUNT_SIGN_OUT_REQUEST_KEY = "vscode.codexAccount.signOutRequest";
@@ -21,23 +22,33 @@ function readCodexAccountInfo(state) {
             status: "unknown"
         };
     }
-    const rateLimit = account.rateLimit;
-    const validRateLimit = rateLimit && typeof rateLimit === "object" && typeof rateLimit.usedPercent === "number" && Number.isFinite(rateLimit.usedPercent) && rateLimit.usedPercent >= 0 && rateLimit.usedPercent <= 100 && (rateLimit.windowDurationMins === undefined || (typeof rateLimit.windowDurationMins === "number" && Number.isFinite(rateLimit.windowDurationMins) && rateLimit.windowDurationMins > 0)) && (rateLimit.resetsAt === undefined || (typeof rateLimit.resetsAt === "number" && Number.isFinite(rateLimit.resetsAt) && rateLimit.resetsAt > 0));
     return {
         status: account.status,
         email: typeof account.email === "string" ? account.email : undefined,
         planType: typeof account.planType === "string" ? account.planType : undefined,
         profileImage: readProfileImageReference(account.profileImage),
         requiresOpenaiAuth: typeof account.requiresOpenaiAuth === "boolean" ? account.requiresOpenaiAuth : undefined,
-        rateLimit: validRateLimit ? {
-            usedPercent: rateLimit.usedPercent,
-            windowDurationMins: rateLimit.windowDurationMins,
-            resetsAt: rateLimit.resetsAt
-        } : undefined,
+        observedAt: typeof account.observedAt === "number" && Number.isFinite(account.observedAt) && account.observedAt >= 0 ? account.observedAt : undefined,
+        rateLimit: readRateLimitInfo(account.rateLimit),
+        rateLimits: Array.isArray(account.rateLimits) ? account.rateLimits.map(readRateLimitInfo).filter(limit => limit !== undefined) : undefined,
         authUrl: typeof account.authUrl === "string" ? account.authUrl : undefined,
         authUrlNonce: typeof account.authUrlNonce === "string" ? account.authUrlNonce : undefined
     };
 }
+function readRateLimitInfo(value) {
+    if (!value || typeof value !== "object") {
+        return undefined;
+    }
+    const rateLimit = value;
+    if (typeof rateLimit.usedPercent !== "number" || !Number.isFinite(rateLimit.usedPercent) || rateLimit.usedPercent < 0 || rateLimit.usedPercent > 100 || (rateLimit.windowDurationMins !== undefined && (typeof rateLimit.windowDurationMins !== "number" || !Number.isFinite(rateLimit.windowDurationMins) || rateLimit.windowDurationMins <= 0)) || (rateLimit.resetsAt !== undefined && (typeof rateLimit.resetsAt !== "number" || !Number.isFinite(rateLimit.resetsAt) || rateLimit.resetsAt <= 0))) {
+        return undefined;
+    }
+    return {
+        usedPercent: rateLimit.usedPercent,
+        windowDurationMins: rateLimit.windowDurationMins,
+        resetsAt: rateLimit.resetsAt
+    };
+}
 function readProfileImageReference(value) {
     if (!value || typeof value !== "object") {
         return undefined;
@@ -66,4 +77,4 @@ function isProfileImageResourceUri(value, contentType, nonce) {
     }
 }
 
-export { CODEX_ACCOUNT_META_KEY, CODEX_ACCOUNT_SIGN_IN_REQUEST_KEY, CODEX_ACCOUNT_SIGN_OUT_REQUEST_KEY, CODEX_PROFILE_IMAGE_SCHEME, MAX_CODEX_PROFILE_IMAGE_BYTES, readCodexAccountInfo };
+export { CODEX_ACCOUNT_META_KEY, CODEX_ACCOUNT_REFRESH_REQUEST_KEY, CODEX_ACCOUNT_SIGN_IN_REQUEST_KEY, CODEX_ACCOUNT_SIGN_OUT_REQUEST_KEY, CODEX_PROFILE_IMAGE_SCHEME, MAX_CODEX_PROFILE_IMAGE_BYTES, readCodexAccountInfo };

package/vscode/src/vs/platform/agentHost/common/meta/vscode/copilotBackgroundWorkMeta.d.ts

@@ -0,0 +1,10 @@
+/** Builds the `_meta` for a Copilot background shell entry. */
+export declare function toCopilotBackgroundShellMeta(shellId: string, attachment: "attached" | "detached"): Record<string, unknown>;
+/** Reads Copilot's shell identifier, when the host provided one. */
+export declare function readCopilotShellId(work: {
+    readonly _meta?: Record<string, unknown>;
+}): string | undefined;
+/** Reads whether a Copilot shell is attached to its agent's lifetime, when the host provided it. */
+export declare function readCopilotShellAttachment(work: {
+    readonly _meta?: Record<string, unknown>;
+}): "attached" | "detached" | undefined;

package/vscode/src/vs/platform/agentHost/common/meta/vscode/copilotBackgroundWorkMeta.js

@@ -0,0 +1,14 @@
+
+
+const COPILOT_SHELL_ID_META_KEY = 'vscode.copilot.shellId';
+const COPILOT_SHELL_ATTACHMENT_META_KEY = 'vscode.copilot.shellAttachment';
+function readCopilotShellId(work) {
+    const shellId = work._meta?.[COPILOT_SHELL_ID_META_KEY];
+    return typeof shellId === 'string' ? shellId : undefined;
+}
+function readCopilotShellAttachment(work) {
+    const attachment = work._meta?.[COPILOT_SHELL_ATTACHMENT_META_KEY];
+    return attachment === 'attached' || attachment === 'detached' ? attachment : undefined;
+}
+
+export { readCopilotShellAttachment, readCopilotShellId };

package/vscode/src/vs/platform/agentHost/common/meta/vscode/mcpCustomizationMeta.d.ts

@@ -0,0 +1,34 @@
+import type { McpServerCustomization } from "../../state/protocol/state.js";
+export type McpServerSource = "user" | "workspace" | "plugin" | "builtin" | "managed" | "account";
+/** Reads the runtime-reported configuration source, independently of the server's lifecycle state. */
+export declare function readMcpServerSource(customization: McpServerCustomization | undefined): McpServerSource | undefined;
+/**
+ * Records the configuration source in an open metadata bag. An absent source removes a previously
+ * recorded one, because it describes the current configuration; every other entry is preserved.
+ */
+export declare function withMcpServerSourceMeta(meta: Record<string, unknown> | undefined, source: McpServerSource | undefined): Record<string, unknown> | undefined;
+/** Reads an optional Connector catalog name without changing the MCP server's runtime identity. */
+export declare function readMcpServerDisplayName(customization: McpServerCustomization | undefined): string | undefined;
+/** Records an optional Connector catalog name while preserving every other metadata entry. */
+export declare function withMcpServerDisplayNameMeta(meta: Record<string, unknown> | undefined, displayName: string | undefined): Record<string, unknown> | undefined;
+/**
+ * Reads the plugin the runtime reports as the source of the server's configuration. The
+ * plugin may be one the client never published, such as a plugin bundled with the agent.
+ */
+export declare function readMcpServerSourcePlugin(customization: McpServerCustomization | undefined): string | undefined;
+/**
+ * Records the runtime-reported source plugin in an open metadata bag. An absent plugin removes a
+ * previously recorded one, because it describes the current configuration; every other entry is preserved.
+ */
+export declare function withMcpServerSourcePluginMeta(meta: Record<string, unknown> | undefined, sourcePlugin: string | undefined): Record<string, unknown> | undefined;
+/**
+ * Reads the VS Code setting a VS Code agent host declares as controlling whether it includes a server.
+ * Only the host that owns the server can declare this; clients must not infer it from the server's name,
+ * because another host can publish a server with the same name that the setting cannot control.
+ */
+export declare function readMcpServerControllingSetting(customization: McpServerCustomization | undefined): string | undefined;
+/**
+ * Records the VS Code setting that controls whether the host includes a server. An absent setting removes a
+ * previously recorded one; every other entry is preserved.
+ */
+export declare function withMcpServerControllingSettingMeta(meta: Record<string, unknown> | undefined, settingId: string | undefined): Record<string, unknown> | undefined;

package/vscode/src/vs/platform/agentHost/common/meta/vscode/mcpCustomizationMeta.js

@@ -0,0 +1,42 @@
+
+
+const sourceKey = "agentHost.mcpServerSource";
+const displayNameKey = "vscode.mcpServerDisplayName";
+const maxDisplayNameLength = 512;
+const sourcePluginKey = "agentHost.mcpServerSourcePlugin";
+const controllingSettingKey = "vscode.mcpServerControllingSetting";
+function readMcpServerSource(customization) {
+    const source = customization?._meta?.[sourceKey];
+    switch (source) {
+    case "user":
+    case "workspace":
+    case "plugin":
+    case "builtin":
+    case "managed":
+    case "account":
+        return source;
+    default:
+        return undefined;
+    }
+}
+function readMcpServerDisplayName(customization) {
+    return normalizeMcpServerDisplayName(customization?._meta?.[displayNameKey]);
+}
+function normalizeMcpServerDisplayName(value) {
+    if (typeof value !== "string") {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    return trimmed.length > 0 && trimmed.length <= maxDisplayNameLength ? trimmed : undefined;
+}
+function readMcpServerSourcePlugin(customization) {
+    return readNonEmptyString(customization?._meta?.[sourcePluginKey]);
+}
+function readMcpServerControllingSetting(customization) {
+    return readNonEmptyString(customization?._meta?.[controllingSettingKey]);
+}
+function readNonEmptyString(value) {
+    return typeof value === "string" && value.trim().length > 0 ? value : undefined;
+}
+
+export { readMcpServerControllingSetting, readMcpServerDisplayName, readMcpServerSource, readMcpServerSourcePlugin };

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

@@ -0,0 +1,9 @@
+import { IMissionControlEnvironment } from "@codingame/monaco-vscode-chat-service-override/vscode/vs/platform/agentHost/common/cloudSandboxAgentHost";
+export declare const AgentHostRemoteConnectionsSettingId = "chat.agentHost.remoteConnections";
+/** Logical identity for host-side Mission Control wire logs, including failed handshakes. */
+export declare const MISSION_CONTROL_AHP_LOG_ID = "mission-control";
+export type AgentHostRemoteConnectionsBackend = "devTunnel" | "githubEnvironment" | "missionControl";
+export declare function isGitHubEnvironmentBackend(backend: AgentHostRemoteConnectionsBackend): boolean;
+export interface IMissionControlHost extends IMissionControlEnvironment {
+    readonly displayName?: string;
+}

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

@@ -0,0 +1,9 @@
+
+
+const AgentHostRemoteConnectionsSettingId = 'chat.agentHost.remoteConnections';
+const MISSION_CONTROL_AHP_LOG_ID = 'mission-control';
+function isGitHubEnvironmentBackend(backend) {
+    return backend === 'githubEnvironment' || backend === 'missionControl';
+}
+
+export { AgentHostRemoteConnectionsSettingId, MISSION_CONTROL_AHP_LOG_ID, isGitHubEnvironmentBackend };

package/vscode/src/vs/platform/agentHost/common/missionControlEnvironment.service.d.ts

@@ -0,0 +1,26 @@
+import { CancellationToken } from "../../../base/common/cancellation.js";
+import { IObservable } from "../../../base/common/observable.js";
+import { URI } from "../../../sessions/sessions.web.main.internal.js";
+import { IMissionControlHost } from "./missionControlEnvironment.js";
+export declare const IMissionControlSharingService: import("../../instantiation/common/instantiation.js").ServiceIdentifier<IMissionControlSharingService>;
+/** Owns the local environment's explicit Mission Control sharing opt-in. */
+export interface IMissionControlSharingService {
+    readonly _serviceBrand: undefined;
+    readonly state: IObservable<"disabled" | "connecting" | "enabled">;
+    setEnabled(enabled: boolean): Promise<void>;
+    /** Supplies the local folder catalogue from the window's workspace-selection surface. */
+    setProjectFolders(folders: readonly URI[]): void;
+}
+export declare const IMissionControlEnvironmentService: import("../../instantiation/common/instantiation.js").ServiceIdentifier<IMissionControlEnvironmentService>;
+/** Account/profile-local inventory; discovery and local preferences never provision or attach compute. */
+export interface IMissionControlEnvironmentService {
+    readonly _serviceBrand: undefined;
+    readonly hosts: IObservable<readonly IMissionControlHost[]>;
+    readonly accountKey: string | undefined;
+    readonly enabled: boolean;
+    initialize(): Promise<void>;
+    refresh(token: CancellationToken): Promise<void>;
+    connect(id: string, token: CancellationToken): Promise<void>;
+    disconnect(id: string): Promise<void>;
+    setDisplayName(id: string, name: string | undefined): void;
+}

package/vscode/src/vs/platform/agentHost/common/missionControlEnvironment.service.js

@@ -0,0 +1,7 @@
+
+import { createDecorator } from '../../instantiation/common/instantiation.js';
+
+const IMissionControlSharingService = ( createDecorator("missionControlSharingService"));
+const IMissionControlEnvironmentService = ( createDecorator("missionControlEnvironmentService"));
+
+export { IMissionControlEnvironmentService, IMissionControlSharingService };

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

@@ -33,13 +33,13 @@ export declare function isSendMessageTool(toolName: string): boolean;
  * ecosystem-wide invariant (an absent chat id already means "the default chat"),
  * so it is enforced here once rather than at each call site.
  */
-export declare function buildOpenSessionLinkUri(backendSession: URI | string, chatId?: string, turnId?: string): string;
+export declare function buildOpenSessionLinkUri(backendSession: URI | string, chatId?: string, turnId?: string, connectionAuthority?: string): string;
 /**
  * Builds a product protocol URL that opens an agent-host session in the Agents window.
  *
  * Shape: `<product-protocol>://agents/agent-host-session/<provider>/<rawSessionId>[/chat/<chatId>]`.
  */
-export declare function buildExternalOpenSessionLinkUri(productUrlProtocol: string, backendSession: URI | string, chatId?: string, turnId?: string): string;
+export declare function buildExternalOpenSessionLinkUri(productUrlProtocol: string, backendSession: URI | string, chatId?: string, turnId?: string, connectionAuthority?: string): string;
 /**
  * Recovers the internal agent-host session link carried by an Agents product protocol URL.
  */
@@ -61,6 +61,7 @@ export declare function parseOpenSessionLinkUri(uri: URI | string): URI | undefi
  */
 export declare function parseOpenSessionLinkChatId(uri: URI | string): string | undefined;
 export declare function parseOpenSessionLinkTurnId(uri: URI | string): string | undefined;
+export declare function parseOpenSessionLinkConnectionAuthority(uri: URI | string): string | undefined;
 /**
  * Builds an {@link AGENT_HOST_SESSION_LINK_SCHEME} link that opens the chat
  * identified by an AHP chat channel URI (`ahp-chat://...`) or a bare backend