public static ID = 'CopilotRemoteAgentManager';

private readonly _stateModel: CopilotStateModel;

private readonly _onDidChangeStates = this._register(new vscode.EventEmitter<void>());

readonly onDidChangeStates = this._onDidChangeStates.event;

private readonly _onDidChangeNotifications = this._register(new vscode.EventEmitter<PullRequestModel[]>());

readonly onDidChangeNotifications = this._onDidChangeNotifications.event;

private readonly _onDidCreatePullRequest = this._register(new vscode.EventEmitter<number>());

readonly onDidCreatePullRequest = this._onDidCreatePullRequest.event;

private readonly _onDidChangeChatSessions = this._register(new vscode.EventEmitter<void>());

readonly onDidChangeChatSessions = this._onDidChangeChatSessions.event;

private readonly _config: CopilotRemoteAgentConfig;

private readonly gitOperationsManager: GitOperationsManager;

constructor(private credentialStore: CredentialStore, public repositoriesManager: RepositoriesManager, private telemetry: ITelemetry) {

super();

this.gitOperationsManager = new GitOperationsManager(CopilotRemoteAgentManager.ID);

this._register(this.credentialStore.onDidChangeSessions((e: vscode.AuthenticationSessionsChangeEvent) => {

if (e.provider.id === 'github') {

this._copilotApiPromise = undefined; // Invalidate cached session

}

}));

this._stateModel = new CopilotStateModel();

this._register(new CopilotPRWatcher(this.repositoriesManager, this._stateModel));

this._register(this._stateModel.onDidChangeStates(() => this._onDidChangeStates.fire()));

this._register(this._stateModel.onDidChangeNotifications(items => this._onDidChangeNotifications.fire(items)));

this._register(this.repositoriesManager.onDidChangeFolderRepositories((event) => {

if (event.added) {

this._register(event.added.onDidChangeAssignableUsers(() => {

this.updateAssignabilityContext();

}));

}

this.updateAssignabilityContext();

}));

this.repositoriesManager.folderManagers.forEach(manager => {

this._register(manager.onDidChangeAssignableUsers(() => {

this.updateAssignabilityContext();

}));

});

this._register(vscode.workspace.onDidChangeConfiguration((e) => {

if (e.affectsConfiguration(CODING_AGENT)) {

this.updateAssignabilityContext();

}

}));

// Set initial context

this.updateAssignabilityContext();

this._config = new CopilotRemoteAgentConfig();

}

private _copilotApiPromise: Promise<CopilotApi | undefined> | undefined;

private get copilotApi(): Promise<CopilotApi | undefined> {

if (!this._copilotApiPromise) {

this._copilotApiPromise = this.initializeCopilotApi();

}

return this._copilotApiPromise;

}

private async initializeCopilotApi(): Promise<CopilotApi | undefined> {

return await getCopilotApi(this.credentialStore, this.telemetry);

}

public get enabled(): boolean {

return this._config.enabled;

}

public get autoCommitAndPushEnabled(): boolean {

return this._config.autoCommitAndPushEnabled;

}

private _repoManagerInitializationPromise: Promise<void> | undefined;

private async waitRepoManagerInitialization() {

if (this.repositoriesManager.state === ReposManagerState.RepositoriesLoaded || this.repositoriesManager.state === ReposManagerState.NeedsAuthentication) {

return;

}

if (!this._repoManagerInitializationPromise) {

this._repoManagerInitializationPromise = new Promise((resolve) => {

const disposable = this.repositoriesManager.onDidChangeState(() => {

if (this.repositoriesManager.state === ReposManagerState.RepositoriesLoaded || this.repositoriesManager.state === ReposManagerState.NeedsAuthentication) {

disposable.dispose();

resolve();

}

});

});

}

return this._repoManagerInitializationPromise;

}

async isAssignable(): Promise<boolean> {

const repoInfo = await this.repoInfo();

if (!repoInfo) {

return false;

}

const { fm } = repoInfo;

try {

// Ensure assignable users are loaded

await fm.getAssignableUsers();

const allAssignableUsers = fm.getAllAssignableUsers();

if (!allAssignableUsers) {

return false;

}

// Check if any of the copilot logins are in the assignable users

return allAssignableUsers.some(user => COPILOT_LOGINS.includes(user.login));

} catch (error) {

// If there's an error fetching assignable users, assume not assignable

return false;

}

}

async isAvailable(): Promise<boolean> {

// Check if the manager is enabled, copilot API is available, and it's assignable

if (!this._config.enabled) {

return false;

}

const repoInfo = await this.repoInfo();

if (!repoInfo) {

return false;

}

const copilotApi = await this.copilotApi;

if (!copilotApi) {

return false;

}

return await this.isAssignable();

}

private async updateAssignabilityContext(): Promise<void> {

try {

const available = await this.isAvailable();

commands.setContext('copilotCodingAgentAssignable', available);

} catch (error) {

// Presume false

commands.setContext('copilotCodingAgentAssignable', false);

}

}

async repoInfo(): Promise<RepoInfo | undefined> {

if (!this.repositoriesManager.folderManagers.length) {

return;

}

const fm = this.repositoriesManager.folderManagers[0];

const repository = fm?.repository;

const ghRepository = fm?.gitHubRepositories.find(repo => repo.remote instanceof GitHubRemote) as GitHubRepository | undefined;

if (!repository || !ghRepository) {

return;

}

const baseRef = repository.state.HEAD?.name; // TODO: Consider edge cases

const ghRemotes = await fm.getGitHubRemotes();

if (!ghRemotes || ghRemotes.length === 0) {

return;

}

const remote =

ghRemotes.find(remote => remote.remoteName === 'origin')

|| ghRemotes[0]; // Fallback to the first remote

// Extract repo data from target remote

const { owner, repositoryName: repo } = remote;

if (!owner || !repo || !baseRef || !repository) {

return;

}

return { owner, repo, baseRef, remote, repository, ghRepository, fm };

}

async addFollowUpToExistingPR(pullRequestNumber: number, userPrompt: string, summary?: string): Promise<string | undefined> {

const repoInfo = await this.repoInfo();

if (!repoInfo) {

return;

}

try {

const ghRepo = repoInfo.ghRepository;

const pr = await ghRepo.getPullRequest(pullRequestNumber);

if (!pr) {

Logger.error(`Could not find pull request #${pullRequestNumber}`, CopilotRemoteAgentManager.ID);

return;

}

// Add a comment tagging @copilot with the user's prompt

const commentBody = `${COPILOT} ${userPrompt} \n\n --- \n\n ${summary ?? ''}`;

const commentResult = await pr.createIssueComment(commentBody);

if (!commentResult) {

Logger.error(`Failed to add comment to PR #${pullRequestNumber}`, CopilotRemoteAgentManager.ID);

return;

}

Logger.appendLine(`Added comment ${commentResult.htmlUrl}`, CopilotRemoteAgentManager.ID);

// allow-any-unicode-next-line

return vscode.l10n.t('🚀 Follow-up comment added to [#{0}]({1})', pullRequestNumber, commentResult.htmlUrl);

} catch (err) {

Logger.error(`Failed to add follow-up comment to PR #${pullRequestNumber}: ${err}`, CopilotRemoteAgentManager.ID);

return;

}

}

async commandImpl(args?: ICopilotRemoteAgentCommandArgs): Promise<string | ICopilotRemoteAgentCommandResponse | undefined> {

if (!args) {

return;

}

const { userPrompt, summary, source, followup, _version } = args;

/* __GDPR__

this.telemetry.sendTelemetryEvent('remoteAgent.command.args', {

source: source?.toString() || 'unknown',

isFollowup: !!followup ? 'true' : 'false',

userPromptLength: userPrompt.length.toString(),

summaryLength: summary ? summary.length.toString() : '0',

version: _version?.toString() || 'unknown'

});

if (!userPrompt || userPrompt.trim().length === 0) {

return;

}

const repoInfo = await this.repoInfo();

if (!repoInfo) {

/* __GDPR__

this.telemetry.sendTelemetryErrorEvent('remoteAgent.command.result', { reason: 'noRepositoryInfo' });

return;

}

const { repository, owner, repo } = repoInfo;

const repoName = `${owner}/${repo}`;

const hasChanges = repository.state.workingTreeChanges.length > 0 || repository.state.indexChanges.length > 0;

const learnMoreCb = async () => {

/* __GDPR__

this.telemetry.sendTelemetryErrorEvent('remoteAgent.command.result', { reason: 'learnMore' });

vscode.env.openExternal(vscode.Uri.parse('https://aka.ms/coding-agent-docs'));

};

let autoPushAndCommit = false;

const message = vscode.l10n.t('Copilot coding agent will continue your work in \'{0}\'.', repoName);

const detail = vscode.l10n.t('Your chat context will be used to continue work in a new pull request.');

if (source !== 'prompt' && hasChanges && this._config.autoCommitAndPushEnabled) {

// Pending changes modal

const modalResult = await vscode.window.showInformationMessage(

message,

{

modal: true,

detail,

},

PUSH_CHANGES,

CONTINUE_WITHOUT_PUSHING,

LEARN_MORE,

);

if (!modalResult) {

/* __GDPR__

this.telemetry.sendTelemetryErrorEvent('remoteAgent.command.result', { reason: 'cancel' });

return;

}

if (modalResult === LEARN_MORE) {

learnMoreCb();

return;

}

if (modalResult === PUSH_CHANGES) {

autoPushAndCommit = true;

}

} else if (this._config.promptForConfirmation) {

// No pending changes modal

const modalResult = await vscode.window.showInformationMessage(

source !== 'prompt' ? message : vscode.l10n.t('Copilot coding agent will implement the specification outlined in this prompt file'),

{

modal: true,

detail: source !== 'prompt' ? detail : undefined

},

CONTINUE,

CONTINUE_AND_DO_NOT_ASK_AGAIN,

LEARN_MORE,

);

if (!modalResult) {

return;

}

if (modalResult === CONTINUE_AND_DO_NOT_ASK_AGAIN) {

await this._config.disablePromptForConfirmation();

}

if (modalResult === LEARN_MORE) {

learnMoreCb();

return;

}

}

const result = await this.invokeRemoteAgent(

userPrompt,

summary || userPrompt,

autoPushAndCommit,

);

if (result.state !== 'success') {

/* __GDPR__

this.telemetry.sendTelemetryErrorEvent('remoteAgent.command.result', { reason: 'invocationFailure' });

vscode.window.showErrorMessage(result.error);

return;

}

const { webviewUri, link, number } = result;

/* __GDPR__

this.telemetry.sendTelemetryEvent('remoteAgent.command.success', {

source: source || 'unknown',

hasFollowup: (!!followup).toString(),

outcome: 'success'

});

this._onDidChangeChatSessions.fire();

const viewLocationSetting = vscode.workspace.getConfiguration('chat').get('agentSessionsViewLocation');

const pr = await (async () => {

const capi = await this.copilotApi;

if (!capi) {

return;

}

const sessions = await capi.getAllCodingAgentPRs(this.repositoriesManager);

return sessions.find(session => session.number === number);

})();

if (!viewLocationSetting || viewLocationSetting === 'disabled') {

vscode.commands.executeCommand('vscode.open', webviewUri);

} else {

await this.provideChatSessions(new vscode.CancellationTokenSource().token);

if (pr) {

vscode.window.showChatSession('copilot-swe-agent', `${pr.number}`, {});

}

}

if (pr && (_version && _version === 2)) { /* version 2 means caller knows how to render this */

return {

uri: webviewUri.toString(),

title: pr.title,

description: pr.body,

author: COPILOT_ACCOUNTS[pr.author.login].name,

linkTag: `#${pr.number}`

};

}

// allow-any-unicode-next-line

return vscode.l10n.t('🚀 Coding agent will continue work in [#{0}]({1}). Track progress [here]({2}).', number, link, webviewUri.toString());

}

async invokeRemoteAgent(prompt: string, problemContext: string, autoPushAndCommit = true): Promise<RemoteAgentResult> {

const capiClient = await this.copilotApi;

if (!capiClient) {

return { error: vscode.l10n.t('Failed to initialize Copilot API'), state: 'error' };

}

const repoInfo = await this.repoInfo();

if (!repoInfo) {

return { error: vscode.l10n.t('No repository information found. Please open a workspace with a GitHub repository.'), state: 'error' };

}

const { owner, repo, remote, repository, ghRepository, baseRef } = repoInfo;

// NOTE: This is as unobtrusive as possible with the current high-level APIs.

// We only create a new branch and commit if there are staged or working changes.

// This could be improved if we add lower-level APIs to our git extension (e.g. in-memory temp git index).

let ref = baseRef;

const hasChanges = autoPushAndCommit && (repository.state.workingTreeChanges.length > 0 || repository.state.indexChanges.length > 0);

if (hasChanges) {

if (!this._config.autoCommitAndPushEnabled) {

return { error: vscode.l10n.t('Uncommitted changes detected. Please commit or stash your changes before starting the remote agent. Enable \'{0}\' to push your changes automatically.', CODING_AGENT_AUTO_COMMIT_AND_PUSH), state: 'error' };

}

try {

await this.gitOperationsManager.commitAndPushChanges(repoInfo);

} catch (error) {

return { error: error.message, state: 'error' };

}

}

const base_ref = hasChanges ? baseRef : ref;

try {

if (!(await ghRepository.hasBranch(base_ref))) {

if (!this._config.autoCommitAndPushEnabled) {

// We won't auto-push a branch if the user has disabled the setting

return { error: vscode.l10n.t('The branch \'{0}\' does not exist on the remote repository \'{1}/{2}\'. Please create the remote branch first.', base_ref, owner, repo), state: 'error' };

}

// Push the branch

Logger.appendLine(`Base ref needs to exist on remote. Auto pushing base_ref '${base_ref}' to remote repository '${owner}/${repo}'`, CopilotRemoteAgentManager.ID);

await repository.push(remote.remoteName, base_ref, true);

}

} catch (error) {

return { error: vscode.l10n.t('Failed to configure base branch \'{0}\' does not exist on the remote repository \'{1}/{2}\'. Please create the remote branch first.', base_ref, owner, repo), state: 'error' };

}

let title = prompt;

const titleMatch = problemContext.match(/TITLE: \s*(.*)/i);

if (titleMatch && titleMatch[1]) {

title = titleMatch[1].trim();

}

const formatBodyPlaceholder = (problemContext: string): string => {

const header = vscode.l10n.t('Coding agent has begun work on **{0}** and will replace this description as work progresses.', title);

const collapsedContext = `<details><summary>${vscode.l10n.t('See problem context')}</summary>\n\n${problemContext}\n\n</details>`;

return `${header}\n\n${collapsedContext}`;

};

const problemStatement: string = `${prompt} ${problemContext ? `: ${problemContext}` : ''}`;

const payload: RemoteAgentJobPayload = {

problem_statement: problemStatement,

event_type: 'visual_studio_code_remote_agent_tool_invoked',

pull_request: {

title,

body_placeholder: formatBodyPlaceholder(problemContext),

base_ref,

body_suffix,

...(hasChanges && { head_ref: ref })

}

};

try {

const { pull_request } = await capiClient.postRemoteAgentJob(owner, repo, payload);

this._onDidCreatePullRequest.fire(pull_request.number);

const webviewUri = await toOpenPullRequestWebviewUri({ owner, repo, pullRequestNumber: pull_request.number });

const prLlmString = `The remote agent has begun work and has created a pull request. Details about the pull request are being shown to the user. If the user wants to track progress or iterate on the agent's work, they should use the pull request.`;

return {

state: 'success',

number: pull_request.number,

link: pull_request.html_url,

webviewUri,

llmDetails: hasChanges ? `The pending changes have been pushed to branch '${ref}'. ${prLlmString}` : prLlmString

};

} catch (error) {

return { error: error.message, state: 'error' };

}

}

async getSessionLogsFromAction(pullRequest: PullRequestModel) {

const capi = await this.copilotApi;

if (!capi) {

return [];

}

const lastRun = await this.getLatestCodingAgentFromAction(pullRequest);

if (!lastRun) {

return [];

}

return await capi.getLogsFromZipUrl(lastRun.logs_url);

}

async getWorkflowStepsFromAction(pullRequest: PullRequestModel): Promise<SessionSetupStep[]> {

const lastRun = await this.getLatestCodingAgentFromAction(pullRequest, 0, false);

if (!lastRun) {

return [];

}

try {

const jobs = await pullRequest.githubRepository.getWorkflowJobs(lastRun.id);

const steps: SessionSetupStep[] = [];

for (const job of jobs) {

if (job.steps) {

for (const step of job.steps) {

steps.push({ name: step.name, status: step.status });

}

}

}

return steps;

} catch (error) {

Logger.error(`Failed to get workflow steps: ${error}`, CopilotRemoteAgentManager.ID);

return [];

}

}

async getLatestCodingAgentFromAction(pullRequest: PullRequestModel, sessionIndex = 0, completedOnly = true): Promise<OctokitCommon.WorkflowRun | undefined> {

const capi = await this.copilotApi;

if (!capi) {

return;

}

const runs = await pullRequest.githubRepository.getWorkflowRunsFromAction(pullRequest.createdAt);

const workflowRuns = runs.flatMap(run => run.workflow_runs);

const padawanRuns = workflowRuns

.filter(run => run.path && run.path.startsWith('dynamic/copilot-swe-agent'))

.filter(run => run.pull_requests?.some(pr => pr.id === pullRequest.id));

const session = padawanRuns.filter(s => !completedOnly || s.status === 'completed').at(sessionIndex);

if (!session) {

return;

}

return this.getLatestRun(padawanRuns);

}

async getSessionLogFromPullRequest(pullRequest: PullRequestModel, sessionIndex = 0, completedOnly = true): Promise<IAPISessionLogs | undefined> {

const capi = await this.copilotApi;

if (!capi) {

return undefined;

}

const sessions = await capi.getAllSessions(pullRequest.id);

const session = sessions.filter(s => !completedOnly || s.state === 'completed').at(sessionIndex);

if (!session) {

return undefined;

}

const logs = await capi.getLogsFromSession(session.id);

// If session is in progress, try to fetch workflow steps to show setup progress

let setupSteps: SessionSetupStep[] | undefined;

if (session.state === 'in_progress' || logs.trim().length === 0) {

try {

// Get workflow steps instead of logs

setupSteps = await this.getWorkflowStepsFromAction(pullRequest);

} catch (error) {

// If we can't fetch workflow steps, don't fail the entire request

Logger.warn(`Failed to fetch workflow steps for session ${session.id}: ${error}`, CopilotRemoteAgentManager.ID);

}

}

return { info: session, logs, setupSteps };

}

async getSessionUrlFromPullRequest(pullRequest: PullRequestModel): Promise<string | undefined> {

const capi = await this.copilotApi;

if (!capi) {

return;

}

const sessions = await this.getLatestCodingAgentFromAction(pullRequest);

if (!sessions) {

return;

}

return sessions.html_url;

}

private getLatestRun<T extends { last_updated_at?: string; updated_at?: string }>(runs: T[]): T {

return runs

.slice()

.sort((a, b) => {

const dateA = new Date(a.last_updated_at ?? a.updated_at ?? 0).getTime();

const dateB = new Date(b.last_updated_at ?? b.updated_at ?? 0).getTime();

return dateB - dateA;

})[0];

}

get notificationsCount(): number {

return this._stateModel.notifications.size;

}

hasNotification(owner: string, repo: string, pullRequestNumber: number): boolean {

const key = this._stateModel.makeKey(owner, repo, pullRequestNumber);

return this._stateModel.notifications.has(key);

}

getStateForPR(owner: string, repo: string, prNumber: number): CopilotPRStatus {

return this._stateModel.get(owner, repo, prNumber);

}

getCounts(): { total: number; inProgress: number; error: number } {

return this._stateModel.getCounts();

}

public async provideChatSessions(token: vscode.CancellationToken): Promise<ChatSessionWithPR[]> {

try {

const capi = await this.copilotApi;

if (!capi) {

return [];

}

// Check if the token is already cancelled

if (token.isCancellationRequested) {

return [];

}

await this.waitRepoManagerInitialization();

const codingAgentPRs = await capi.getAllCodingAgentPRs(this.repositoriesManager);

return await Promise.all(codingAgentPRs.map(async session => {

const timeline = await session.getTimelineEvents(session);

const status = copilotEventToStatus(mostRecentCopilotEvent(timeline));

if (status !== CopilotPRStatus.Completed && status !== CopilotPRStatus.Failed) {

const disposable = session.onDidChange(() => {

this._onDidChangeChatSessions.fire();

disposable.dispose(); // Clean up listener after firing

});

this._register(disposable);

}

return {

id: `${session.number}`,

label: session.title || `Session ${session.number}`,

iconPath: this.getIconForSession(status),

pullRequest: session

};

}));

} catch (error) {

Logger.error(`Failed to provide coding agents information: ${error}`, CopilotRemoteAgentManager.ID);

}

return [];

}

public async provideChatSessionContent(id: string, token: vscode.CancellationToken): Promise<vscode.ChatSession> {

try {

const capi = await this.copilotApi;

if (!capi || token.isCancellationRequested) {

return this.createEmptySession();

}

const pullRequestNumber = parseInt(id);

if (isNaN(pullRequestNumber)) {

Logger.error(`Invalid pull request number: ${id}`, CopilotRemoteAgentManager.ID);

return this.createEmptySession();

}

await this.waitRepoManagerInitialization();

const pullRequest = await this.findPullRequestById(pullRequestNumber, true);

if (!pullRequest) {

Logger.error(`Pull request not found: ${pullRequestNumber}`, CopilotRemoteAgentManager.ID);

return this.createEmptySession();

}

const sessions = await capi.getAllSessions(pullRequest.id);

if (!sessions || sessions.length === 0) {

Logger.warn(`No sessions found for pull request ${pullRequestNumber}`, CopilotRemoteAgentManager.ID);

return this.createEmptySession();

}

if (!Array.isArray(sessions)) {

Logger.error(`getAllSessions returned non-array: ${typeof sessions}`, CopilotRemoteAgentManager.ID);

return this.createEmptySession();

}

const contentBuilder = new ChatSessionContentBuilder(CopilotRemoteAgentManager.ID, COPILOT, () => this.getChangeModels(pullRequest));

const history = await contentBuilder.buildSessionHistory(sessions, pullRequest, capi);

const activeResponseCallback = this.findActiveResponseCallback(sessions, pullRequest);

const requestHandler = this.createRequestHandlerIfNeeded(pullRequest);

return {

history,

activeResponseCallback,

requestHandler

};

} catch (error) {

Logger.error(`Failed to provide chat session content: ${error}`, CopilotRemoteAgentManager.ID);

return this.createEmptySession();

}

}

private findActiveResponseCallback(

sessions: SessionInfo[],

pullRequest: PullRequestModel

): ((stream: vscode.ChatResponseStream, token: vscode.CancellationToken) => Thenable<void>) | undefined {

// Only the latest in-progress session gets activeResponseCallback

const inProgressSession = sessions

.slice()

.sort((a, b) => new Date(b.created_at).getTime() - new Date(a.created_at).getTime())

.find(session => session.state === 'in_progress');

if (inProgressSession) {

return this.createActiveResponseCallback(pullRequest, inProgressSession.id);

}

return undefined;

}

private createRequestHandlerIfNeeded(pullRequest: PullRequestModel): vscode.ChatRequestHandler | undefined {

return (pullRequest.state === GithubItemStateEnum.Open)