Chat Session ID and Completion Status API

[pbraddemarco-gif]

Select Topic Area

Question

Copilot Feature Area

Visual Studio

Body

When using vscode.chat. to programmatically invoke Copilot Chat functionality, there's no way to:

1. Get a session ID for the chat request or focus on a specific chat session
2. Know when the agent has finished responding
3. Detect if the agent is still working vs. crashed
4. This makes it difficult to build orchestration extensions that need to chain multiple agent invocations sequentially.

Use Case : Our extension orchestrates multi-step and multi-agent workflows

1. Invoke Execution Agent with a task
2. Wait for agent to complete ⬅️ No API for this
3. Validate the result
4. Invoke next agent in the workflow

Currently we're forced to use file-based workarounds where agents create "completion marker" files that we poll for, which is fragile and unreliable.

What we need - some way to detect when a specific chat participant has finished responding, whether that's:

• An event that fires on completion
• A promise that resolves when done
• A status query API
• Unique session ID and the ability to call it/focus it
• Completion status (active, complete, error, cancelled)
• Event or promise that resolves when the agent finishes

This would enable reliable agent orchestration similar to how tasks, terminals, and debug sessions provide completion signals.

[LuizAlbar]

Yeah, i think you’re not missing anything, this just isn’t exposed right now

Copilot Chat doesn’t give session IDs, completion events, or status info, so theres no clean way to know when an agent is done. That’s why orchestration(agent -> wait -> next agent) ends up relying on hacks like files or timeouts

Definitely feels like a missing API feature, especially for multi-agent workflows like yours

[Skale3628]

You’re running into a real, known limitation of vscode.chat today — and your use case is totally valid.

Current reality (you’re not missing anything)

Right now, Copilot Chat / vscode.chat is fire-and-forget:

❌ No session or conversation ID

❌ No completion event or promise

❌ No status (running / done / failed)

❌ No way to tell if the agent is still working or crashed

So yes — there is currently no supported way to reliably wait for an agent to finish before triggering the next step. Your file-based “completion marker” workaround is unfortunately what many teams end up doing.

Why this exists

Copilot Chat was designed primarily for interactive human use, not as an orchestrated, machine-driven agent runtime. Unlike:

Tasks

Terminals

Debug sessions

…it exposes no lifecycle hooks.

What would actually solve this (you nailed it)

Any of the following would unlock real agent orchestration:

A Promise returned from vscode.chat.request(...)

onDidCompleteChatResponse / onDidFailChatResponse events

Session IDs with queryable state

Status enum: active | complete | error | cancelled

Basically: chat sessions need a lifecycle, just like tasks.

Practical advice (right now)

Until VS Code exposes this officially:

File markers or diagnostics are the least bad option

Avoid timing-based waits (they will break)

Consider delegating orchestration to tasks or language servers, not chat, if possible

Bottom line

You’re not doing anything wrong — the API simply isn’t built for multi-agent orchestration yet. What you’re asking for is reasonable, necessary, and aligns with how every other VS Code execution primitive works.

If this is for a real product, I’d strongly recommend:
opening a VS Code API feature request — this is exactly the kind of gap they need concrete use cases for.

[Ayazxdev]

You’re not overlooking anything — today the vscode.chat / Copilot Chat APIs don’t expose any lifecycle or session primitives for agent invocations.

What’s missing today

There’s currently no supported way to:

• Obtain or reference a chat/session ID
• Await completion of a chat or agent response
• Distinguish in-progress vs completed vs failed execution
• Subscribe to completion / cancellation / error events
• Programmatically focus or resume a specific chat session

As a result, Copilot Chat behaves more like a fire-and-forget UI feature than an orchestratable execution primitive. This makes sequential or multi-agent workflows (agent → validate → next agent) effectively impossible without brittle workarounds like polling files, timeouts, or heuristic output parsing.

Impact on extension authors

For extensions that orchestrate multi-step or multi-agent workflows, this creates a major gap. Other VS Code execution models (tasks, terminals, debug sessions) all provide:

• A stable execution handle
• Completion signals
• Status inspection

Copilot Chat currently provides none of these, forcing extensions into fragile and unreliable patterns.

What would enable reliable orchestration

Any of the following would unlock clean, supported workflows:

• A promise returned from vscode.chat.* that resolves on completion
• Lifecycle events (started, completed, failed, cancelled)
• A unique session ID with a queryable status API

At the moment, there’s no clean or supported solution — this is a genuine platform gap rather than a misuse of the API. If multi-agent workflows are a target use case for Copilot-based extensions, exposing agent execution lifecycle signals would be a foundational improvement.

[josuetamayo05]

s