@volter/supercode-frontend-vscode 0.1.32 → 0.1.34

package/README.md

@@ -373,3 +373,14 @@ routing: stock code broadcasts changes to all input states of a provider. The
 Volter overlay guards this fix with a native regression test. The former legacy
 option-notification queue is no longer required. The narrow reveal/focus bridge
 remains because the native model catalogue and participant identity are provider-wide.
+
+### Native approval cards
+
+A host advertising `volter.chat.inTurnApprovalCapability` version 1 presents
+actual approval requests in its native confirmation card. The original offered
+labels, order and response payloads are preserved. Clicking answers the pending
+request inside the current turn through `supercode.frontend.respondInTurnApproval`;
+it never submits a new chat prompt. The host guards the addressed conversation,
+disables the choices during dispatch and retires them only after an acknowledged
+response or an already-resolved result. Hosts without this capability retain
+stable command buttons. Other request kinds retain their existing presentation.

package/dist/extension.js

@@ -184,6 +184,7 @@ class SupercodeFrontends {
         this.#changed.dispose();
     }
 }
+let nativeInTurnApprovalCards = false;
 function writeProjected(stream, projected, granted, state) {
     for (const candidate of projected) {
         const parts = resolveParts([candidate], granted);
@@ -235,6 +236,12 @@ function writePart(stream, part, state) {
             return;
         }
         case 'answers':
+            if (part.approval && nativeInTurnApprovalCards && part.answers.length > 0) {
+                stream.confirmation(part.title, part.message, {
+                    kind: 'supercode.inTurnApproval', version: 1, answers: part.answers,
+                }, part.answers.map(answer => answer.label));
+                return;
+            }
             // Stable API on purpose: a command button runs INSIDE the live turn,
             // which is when a supercode approval is raised. See `view.ts`.
             stream.markdown(`\n\n**${part.title}**\n\n${part.message}\n\n`);
@@ -300,6 +307,20 @@ export async function activate(context) {
     // description, so this is the grant, not the request.
     const granted = grantedProposals(context.extension.packageJSON);
     log.info(`Volter Harness: proposals requested ${REQUESTED_PROPOSALS.join(', ')}; granted ${granted.size ? [...granted].join(', ') : 'none (stable chat parts only)'}`);
+    // Explicit workbench support is required: stock confirmation clicks send
+    // a new prompt. A missing capability keeps the stable in-turn buttons.
+    if (granted.has('chatParticipantAdditions')) {
+        try {
+            const commands = await vscode.commands.getCommands(true);
+            if (commands.includes('volter.chat.inTurnApprovalCapability')) {
+                const capability = await vscode.commands.executeCommand('volter.chat.inTurnApprovalCapability');
+                nativeInTurnApprovalCards = capability?.version === 1;
+            }
+        }
+        catch (error) {
+            log.warn(`Native in-turn approval cards unavailable: ${String(error)}`);
+        }
+    }
     const controls = await ChatHostControls.fromEnvironment();
     const offerChatGPT = await chatGPTAvailable();
     let signingInWithChatGPT;
@@ -1059,34 +1080,36 @@ export async function activate(context) {
      */
     async function answerRequest(answer) {
         if (!answer || typeof answer.requestId !== 'number')
-            return;
+            return { status: 'unavailable' };
         const connection = frontends.get(answer.connectionId);
         if (!connection) {
             void vscode.window.showWarningMessage('Volter Harness is no longer attached to that runtime.');
-            return;
+            return { status: 'unavailable' };
         }
         const request = connection.session.pendingRequests.get(answer.requestId);
         if (!request) {
             void vscode.window.showInformationMessage(`Volter Harness: request #${answer.requestId} is already resolved.`);
-            return;
+            return { status: 'resolved' };
         }
         let response = answer.response;
         try {
             if (answer.promptForContent) {
                 const content = await requestContent(request);
                 if (content === undefined)
-                    return;
+                    return { status: 'cancelled' };
                 response = { ...response, content };
             }
             await connection.session.respond(response);
             void vscode.window.setStatusBarMessage(`Volter Harness: ${resolutionSentence(response, request, answer.requestId)}`, 4000);
+            return { status: 'responded' };
         }
         catch (error) {
             if (error instanceof RequestNotPendingError) {
                 void vscode.window.showInformationMessage(`Volter Harness: request #${answer.requestId} is already resolved.`);
-                return;
+                return { status: 'resolved' };
             }
             void vscode.window.showErrorMessage(`Volter Harness could not answer request #${answer.requestId}: ${String(error?.message ?? error)}`);
+            return { status: 'failed' };
         }
     }
     const secretKey = (baseUrl) => `supercode.frontend.token:${baseUrl}`;
@@ -1132,7 +1155,7 @@ export async function activate(context) {
     // The one door an answer button uses. It answers the runtime's pending
     // request through `frontend.v2.respond` and narrates itself, because a
     // click whose effect is invisible is a click nobody can trust.
-    vscode.commands.registerCommand('supercode.frontend.respond', (answer) => answerRequest(answer)), vscode.commands.registerCommand('supercode.frontend.status', async (inspect) => {
+    vscode.commands.registerCommand('supercode.frontend.respond', async (answer) => { await answerRequest(answer); }), vscode.commands.registerCommand('supercode.frontend.respondInTurnApproval', (answer) => answerRequest(answer)), vscode.commands.registerCommand('supercode.frontend.status', async (inspect) => {
         if (controls)
             await controls.refresh();
         if (inspect === true)

package/dist/view.d.ts

@@ -15,15 +15,10 @@ export declare const VSCODE_CHAT_LIMITS: Readonly<{
 /**
  * What one answer button sends back to the runtime.
  *
- * MEASURED: `ChatResponseConfirmationPart` is the wrong mechanism here. The
- * editor answers a confirmation by sending a NEW chat request carrying the
- * part's data (`chatConfirmationContentPart`), and a supercode approval is
- * raised WHILE the turn is still running — `decide_approval` in
- * crates/harness/src/server.rs blocks the agent loop until it is answered — so
- * the editor refuses that second request and the click does nothing. An
- * answer is therefore a COMMAND button: it runs inside the live turn, it is
- * stable API (no proposal), and each button carries its own answer instead of
- * the one payload a confirmation splits across accepted/rejected.
+ * Stock confirmations send a new chat request and cannot answer a running
+ * harness turn. Hosts advertising the versioned in-turn approval capability
+ * reuse their native confirmation card while dispatching this exact answer.
+ * Other hosts retain stable command buttons inside the running turn.
  */
 export interface ChatAnswer {
     connectionId: string;
@@ -67,6 +62,7 @@ export type ChatPart = {
     resultText?: string;
 } | {
     part: 'answers';
+    approval: boolean;
     title: string;
     message: string;
     answers: ChatAnswer[];

package/dist/view.js

@@ -386,28 +386,12 @@ export function projectEvent(event, context) {
             const summary = requestSummary(request);
             const answers = requestAnswers(request, context.connectionId);
             const subject = requestSubject(request);
-            const title = subject
-                ? `Approve ${subject}`
-                : `${request.kind === 'approval' ? 'Approval' : 'Assistant'} request #${request.id}`;
-            // Command buttons, and MEASURED rather than assumed. Two richer
-            // mechanisms were tried against a live runtime in the editor's own Chat
-            // view and both failed, so neither ships:
-            //   `ChatResponseConfirmationPart` retires its own buttons on click, but
-            //     the click answers by sending a NEW chat request, and a supercode
-            //     approval is raised while the turn still runs (`decide_approval`
-            //     blocks the agent loop) — the editor refuses that request, so the
-            //     click does nothing and the runtime waits forever.
-            //   `stream.questionCarousel` resolves inside the running turn and the
-            //     widget retires itself — the right shape on paper. Observed: the
-            //     widget renders with its options, Submit retires it, and the
-            //     promise never delivers an answer this frontend can read, so the
-            //     runtime is left blocked. A preferred path that silently swallows
-            //     the answer is worse than a plain one that works.
-            // A command button runs inside the live turn and carries its own answer,
-            // so the runtime's offered answers remain usable. It cannot be withdrawn
-            // once pushed (`chatCommandContentPart` enables on `!isStale` and has no
-            // used-state), so `supercode.frontend.respond` refuses a request that is
-            // no longer pending and SAYS so instead of sending a stale answer.
+            const title = request.kind === 'approval'
+                ? 'Approval required'
+                : subject ? `Approve ${subject}` : `Assistant request #${request.id}`;
+            // The host capability decides whether these original answers can use
+            // a native in-turn confirmation card. Stock confirmation clicks start a
+            // new chat request, so stable command buttons remain the fallback.
             if (context.canRespond === false || (request.payload && typeof request.payload === 'object' && !Array.isArray(request.payload) && request.payload.observe_only === true)) {
                 return [stable({
                         part: 'markdown',
@@ -416,6 +400,7 @@ export function projectEvent(event, context) {
             }
             return [stable({
                     part: 'answers',
+                    approval: request.kind === 'approval',
                     title: clamp(title, VSCODE_CHAT_LIMITS.titleCharacters),
                     message: summary,
                     answers,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@volter/supercode-frontend-vscode",
   "displayName": "Volter Harness",
-  "version": "0.1.32",
+  "version": "0.1.34",
   "type": "module",
   "description": "VS Code chat-view frontend for an existing Volter Harness SDK runtime",
   "publisher": "volter-ai-dev",