@volter/supercode-frontend-vscode 0.1.46 → 0.1.48

package/dist/extension.js

@@ -994,6 +994,22 @@ export async function activate(context) {
         watchApprovals: (connection, stream, token) => watchApprovals(connection, stream, token, () => approvalFor(connection.id)),
     };
     context.subscriptions.push(vscode.commands.registerCommand('supercode.frontend.activateSession', async (resource) => { await connectionFor(vscode.Uri.parse(resource)); }));
+    // A background task the chat named (sayTasks in runTurnInto), stopped through the harness's own control.
+    context.subscriptions.push(vscode.commands.registerCommand('supercode.frontend.stopBackgroundTask', async (connectionId, taskId) => {
+        const connection = frontends.get(connectionId);
+        const task = connection?.session.backgroundTasks.find(candidate => candidate.id === taskId);
+        if (!connection || !task) {
+            void vscode.window.showInformationMessage('That background task is no longer running.');
+            return;
+        }
+        try {
+            const stopped = await connection.session.stopTask(taskId);
+            void vscode.window.showInformationMessage(stopped ? `Stopped ${task.description || taskId}.` : `The harness did not stop ${task.description || taskId}.`);
+        }
+        catch (error) {
+            void vscode.window.showErrorMessage(`Could not stop ${task.description || taskId}: ${String(error?.message ?? error)}`);
+        }
+    }));
     // The host's native focus event is authoritative even when a cached model
     // skips content resolution. Untitled/non-harness focus never starts a runtime.
     context.subscriptions.push(vscode.commands.registerCommand('supercode.frontend.focusSession', (resource) => {
@@ -1210,6 +1226,27 @@ export async function activate(context) {
         });
         const watch = watchApprovals(connection, stream, token, approval);
         state.quiet = watch.answers;
+        // The harness's own background tasks (a Monitor, a background shell): each event one reports is a turn of its own,
+        // which this message waits behind, and nothing here would show it. Said once per change of the set, each with a
+        // way to stop it.
+        let saidTasks = '';
+        const sayTasks = () => {
+            const tasks = connection.session.backgroundTasks;
+            const key = tasks.map(task => task.id).join(',');
+            if (key === saidTasks)
+                return;
+            saidTasks = key;
+            if (!tasks.length) {
+                stream.markdown('\n\n_No background task is running any more._\n\n');
+                return;
+            }
+            stream.markdown(`\n\n_${tasks.length === 1 ? 'A background task is' : `${tasks.length} background tasks are`} still running in this session. The harness answers each of its events as a turn of its own, so this message can wait behind them:_\n\n`);
+            for (const task of tasks) {
+                stream.button({ command: 'supercode.frontend.stopBackgroundTask', title: `Stop ${opaqueText(task.description || task.id, 80)}`, arguments: [connection.id, task.id] });
+            }
+        };
+        sayTasks();
+        const unwatchTasks = connection.session.onChange(sayTasks);
         let completed = false;
         try {
             await connection.session.runTurn(prompt, (event) => {
@@ -1219,6 +1256,7 @@ export async function activate(context) {
             completed = true;
         }
         finally {
+            unwatchTasks();
             watch.dispose();
             cancellation.dispose();
             if (controls && !attachedIds.has(connection.id)) {

package/dist/session.d.ts

@@ -15,6 +15,9 @@ export interface VscodeRuntimeClient {
     steer(prompt: string): Promise<{
         queued: boolean;
     }>;
+    stopTask(taskId: string): Promise<{
+        stopped: boolean;
+    }>;
     interrupt(): Promise<{
         interrupted: boolean;
     }>;
@@ -62,6 +65,12 @@ export declare const TURN_TERMINAL_KINDS: readonly ["turn_succeeded", "turn_fail
  * the view reports.
  */
 export declare const LEASE_ERROR_NAMES: readonly string[];
+/** One of the harness's own background tasks (a Monitor, a background shell), as it last listed them. */
+export interface BackgroundTask {
+    id: string;
+    kind: string;
+    description: string;
+}
 /**
  * One attachment to one already-running Volter Harness SDK runtime: cursor-safe
  * event projection, permission narrowing, and the semantic actions the runtime
@@ -86,6 +95,11 @@ export declare class VscodeFrontendSession {
      */
     replay: FrontendEvent[];
     pendingRequests: Map<number, FrontendRequest>;
+    /**
+     * The harness's own background tasks as it last listed them (`background_tasks`). Each event one reports starts a
+     * turn of its own, so while any runs the session can be busy with turns no one here submitted.
+     */
+    backgroundTasks: BackgroundTask[];
     /**
      * Requests this attachment has seen resolved. `request_resolved` deletes the
      * pending entry while it is being projected, so without this the resolution
@@ -136,6 +150,8 @@ export declare class VscodeFrontendSession {
     submit(prompt: string): Promise<void>;
     steer(prompt: string): Promise<void>;
     interrupt(): Promise<void>;
+    /** Stop one of the harness's own background tasks, by the id it listed it with. */
+    stopTask(taskId: string): Promise<boolean>;
     respond(response: FrontendResponse): Promise<void>;
     detach(): Promise<void>;
     close(): Promise<void>;

package/dist/session.js

@@ -1,3 +1,6 @@
+/** How long a turn waits on a connection that dropped before saying it was lost (the follow loop's re-attach backs
+ *  off to 15 s; this outlasts a few of its attempts). */
+const DISCONNECT_GRACE_MS = 60_000;
 /** The request this attachment tried to answer is no longer open. */
 export class RequestNotPendingError extends Error {
     requestId;
@@ -53,6 +56,11 @@ export class VscodeFrontendSession {
      */
     replay = [];
     pendingRequests = new Map();
+    /**
+     * The harness's own background tasks as it last listed them (`background_tasks`). Each event one reports starts a
+     * turn of its own, so while any runs the session can be busy with turns no one here submitted.
+     */
+    backgroundTasks = [];
     /**
      * Requests this attachment has seen resolved. `request_resolved` deletes the
      * pending entry while it is being projected, so without this the resolution
@@ -102,6 +110,7 @@ export class VscodeFrontendSession {
         const staged = {
             descriptor: structuredClone(snapshot.descriptor),
             pendingRequests: new Map([...this.pendingRequests].map(([id, request]) => [id, structuredClone(request)])),
+            backgroundTasks: structuredClone(this.backgroundTasks),
             cursor: Math.max(this.cursor, snapshot.history_cursor),
         };
         // Validate and project the whole attachment before any observable field
@@ -126,6 +135,7 @@ export class VscodeFrontendSession {
         this.historyCursor = snapshot.history_cursor;
         this.appendTranscript(structuredClone(snapshot.replay));
         this.pendingRequests = staged.pendingRequests;
+        this.backgroundTasks = staged.backgroundTasks;
         this.cursor = staged.cursor;
         this.connection = 'connected';
         this.attachedAtMs ??= Date.now();
@@ -260,6 +270,11 @@ export class VscodeFrontendSession {
             if (request && typeof request.id === 'number')
                 state.pendingRequests.set(request.id, structuredClone(request));
         }
+        if (event.kind === 'background_tasks' && Array.isArray(payload.tasks)) {
+            state.backgroundTasks = payload.tasks
+                .filter(task => task && typeof task.id === 'string')
+                .map(task => ({ id: task.id, kind: String(task.kind ?? 'task'), description: String(task.description ?? '') }));
+        }
         if (event.kind === 'request_resolved' && typeof payload.request_id === 'number') {
             const resolved = state.pendingRequests.get(payload.request_id);
             if (resolved) {
@@ -334,6 +349,11 @@ export class VscodeFrontendSession {
         this.require('interrupt');
         await this.withControl(() => this.client.interrupt());
     }
+    /** Stop one of the harness's own background tasks, by the id it listed it with. */
+    async stopTask(taskId) {
+        const result = await this.withControl(() => this.client.stopTask(taskId));
+        return result?.stopped === true;
+    }
     async respond(response) {
         this.require('respond');
         if (!this.pendingRequests.has(response.request_id))
@@ -402,7 +422,25 @@ export class VscodeFrontendSession {
         // that hangs one is worse than one that ends it a beat early. The
         // descriptor going idle after the submit is the second, independent signal.
         let sawBusy = false;
+        // A stream that ends is re-attached from its cursor (the extension's follow loop), and the replay ends the turn;
+        // only a connection closed, or one still down after DISCONNECT_GRACE_MS, ends the wait, said: a response held open
+        // with nothing in it is the silent failure.
+        let down;
+        const lost = () => fail?.(new Error('The connection to this conversation\'s runtime was lost before its turn ended; the turn may still be running. Reopen the chat to see where it stands.'));
+        finished.catch(() => undefined); // a loss while the submit is still in flight is answered by the submit's own error
         const unwatch = this.onChange(() => {
+            if (this.connection === 'closed') {
+                lost();
+                return;
+            }
+            if (this.connection === 'connected') {
+                clearTimeout(down);
+                down = undefined;
+            }
+            else {
+                down ??= setTimeout(lost, DISCONNECT_GRACE_MS);
+                return;
+            }
             const state = this.descriptor?.turn_state;
             if (state === 'busy')
                 sawBusy = true;
@@ -417,6 +455,7 @@ export class VscodeFrontendSession {
             return await finished;
         }
         finally {
+            clearTimeout(down);
             unsubscribe();
             unwatch();
         }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@volter/supercode-frontend-vscode",
   "displayName": "Volter Harness",
-  "version": "0.1.46",
+  "version": "0.1.48",
   "type": "module",
   "description": "VS Code chat-view frontend for an existing Volter Harness SDK runtime",
   "publisher": "volter-ai-dev",
@@ -190,7 +190,7 @@
   },
   "supercodeFrontendContract": {
     "name": "@volter/supercode-frontend",
-    "version": "0.2.8",
+    "version": "0.2.9",
     "mode": "generated-artifact"
   },
   "license": "MIT OR Apache-2.0"

package/vendor/supercode-frontend/contract.json

@@ -251,6 +251,8 @@
     "Reply": {"kind": "object", "fields": {"reply": {"type": "string"}}},
     "Interrupted": {"kind": "object", "fields": {"interrupted": {"type": "boolean"}}},
     "Queued": {"kind": "object", "fields": {"queued": {"type": "boolean"}}},
+    "TaskParams": {"kind": "object", "fields": {"task_id": {"type": "string"}}},
+    "Stopped": {"kind": "object", "fields": {"stopped": {"type": "boolean"}}},
     "Closed": {"kind": "object", "fields": {"closed": {"type": "boolean"}}}
   },
   "methods": [
@@ -260,6 +262,7 @@
     {"id": "submit", "wire": "frontend.v2.submit", "sdk_action": "input", "params": "MultimodalPromptParams", "result": "Reply", "compatibility": "completion_waiting_alias", "transports": ["local", "http", "websocket", "acp"]},
     {"id": "interrupt", "wire": "frontend.v2.interrupt", "sdk_action": "interrupt", "params": "Empty", "result": "Interrupted", "transports": ["local", "http", "websocket", "acp"]},
     {"id": "steer", "wire": "frontend.v2.steer", "sdk_action": "steer", "params": "PromptParams", "result": "Queued", "transports": ["local", "http", "websocket", "acp"]},
+    {"id": "stop_task", "wire": "frontend.v2.stop_task", "sdk_action": "stop_task", "params": "TaskParams", "result": "Stopped", "transports": ["local", "http", "websocket", "acp"]},
     {"id": "respond", "wire": "frontend.v2.respond", "sdk_action": "respond", "params": "RespondParams", "result": "Accepted", "transports": ["local", "http", "websocket", "acp"]},
     {"id": "invoke", "wire": "frontend.v2.invoke", "sdk_action": "input", "params": "InvokeParams", "result": "FrontendOperationResult", "transports": ["local", "http", "websocket", "acp"]},
     {"id": "lease", "wire": "frontend.v2.lease", "sdk_action": "events", "params": "Empty", "result": "RuntimeLeaseSnapshot", "transports": ["local", "http", "websocket", "acp"]},

package/vendor/supercode-frontend/generated-client.d.mts

@@ -1,5 +1,5 @@
 // @generated by sdk/frontend/generate.mjs from contract.json. Do not edit.
-import type { Accepted, Closed, FrontendAttachSnapshot, FrontendOperationInvocation, FrontendOperationResult, FrontendResponse, FrontendRuntimeDescriptor, FrontendWireMethod, Interrupted, Queued, Reply, RuntimeLeaseSnapshot } from './generated.mjs';
+import type { Accepted, Closed, FrontendAttachSnapshot, FrontendOperationInvocation, FrontendOperationResult, FrontendResponse, FrontendRuntimeDescriptor, FrontendWireMethod, Interrupted, Queued, Reply, RuntimeLeaseSnapshot, Stopped } from './generated.mjs';
 export abstract class GeneratedFrontendClient<Options = unknown> {
   abstract rpc(method: FrontendWireMethod, params?: Record<string, unknown>, options?: Options): Promise<unknown>;
   describe(options?: Options): Promise<FrontendRuntimeDescriptor>;
@@ -8,6 +8,7 @@ export abstract class GeneratedFrontendClient<Options = unknown> {
   submit(prompt: string, options?: Options & {imageUrls?: string[]}): Promise<Reply>;
   interrupt(options?: Options): Promise<Interrupted>;
   steer(prompt: string, options?: Options): Promise<Queued>;
+  stopTask(taskId: string, options?: Options): Promise<Stopped>;
   respond(response: FrontendResponse, options?: Options): Promise<Accepted>;
   invoke(operation: FrontendOperationInvocation, options?: Options): Promise<FrontendOperationResult>;
   lease(options?: Options): Promise<RuntimeLeaseSnapshot>;

package/vendor/supercode-frontend/generated-client.mjs

@@ -9,6 +9,7 @@ export class GeneratedFrontendClient {
   submit(prompt, { imageUrls, ...options } = {}) { return this.rpc(FRONTEND_METHODS.submit, { prompt, ...(imageUrls?.length ? {image_urls:imageUrls} : {}) }, options); }
   interrupt(options) { return this.rpc(FRONTEND_METHODS.interrupt, {}, options); }
   steer(prompt, options) { return this.rpc(FRONTEND_METHODS.steer, { prompt }, options); }
+  stopTask(taskId, options) { return this.rpc(FRONTEND_METHODS.stop_task, { task_id: taskId }, options); }
   respond(response, options) { return this.rpc(FRONTEND_METHODS.respond, { response }, options); }
   invoke(operation, options) { return this.rpc(FRONTEND_METHODS.invoke, { operation }, options); }
   lease(options) { return this.rpc(FRONTEND_METHODS.lease, {}, options); }

package/vendor/supercode-frontend/generated.d.mts

@@ -139,8 +139,14 @@ export interface Interrupted {
 export interface Queued {
   queued: boolean;
 }
+export interface TaskParams {
+  task_id: string;
+}
+export interface Stopped {
+  stopped: boolean;
+}
 export interface Closed {
   closed: boolean;
 }
-export type FrontendMethodId = 'describe' | 'attach' | 'send_input' | 'submit' | 'interrupt' | 'steer' | 'respond' | 'invoke' | 'lease' | 'acquire_control' | 'take_control' | 'heartbeat' | 'detach' | 'close';
-export type FrontendWireMethod = 'frontend.v2.describe' | 'frontend.v2.attach' | 'frontend.v2.send_input' | 'frontend.v2.submit' | 'frontend.v2.interrupt' | 'frontend.v2.steer' | 'frontend.v2.respond' | 'frontend.v2.invoke' | 'frontend.v2.lease' | 'frontend.v2.acquire_control' | 'frontend.v2.take_control' | 'frontend.v2.heartbeat' | 'frontend.v2.detach' | 'frontend.v2.close';
+export type FrontendMethodId = 'describe' | 'attach' | 'send_input' | 'submit' | 'interrupt' | 'steer' | 'stop_task' | 'respond' | 'invoke' | 'lease' | 'acquire_control' | 'take_control' | 'heartbeat' | 'detach' | 'close';
+export type FrontendWireMethod = 'frontend.v2.describe' | 'frontend.v2.attach' | 'frontend.v2.send_input' | 'frontend.v2.submit' | 'frontend.v2.interrupt' | 'frontend.v2.steer' | 'frontend.v2.stop_task' | 'frontend.v2.respond' | 'frontend.v2.invoke' | 'frontend.v2.lease' | 'frontend.v2.acquire_control' | 'frontend.v2.take_control' | 'frontend.v2.heartbeat' | 'frontend.v2.detach' | 'frontend.v2.close';

package/vendor/supercode-frontend/generated.mjs

@@ -7,6 +7,7 @@ export const FRONTEND_METHODS = Object.freeze({
   "submit": "frontend.v2.submit",
   "interrupt": "frontend.v2.interrupt",
   "steer": "frontend.v2.steer",
+  "stop_task": "frontend.v2.stop_task",
   "respond": "frontend.v2.respond",
   "invoke": "frontend.v2.invoke",
   "lease": "frontend.v2.lease",

package/vendor/supercode-frontend/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@volter/supercode-frontend",
-  "version": "0.2.8",
+  "version": "0.2.9",
   "type": "module",
   "description": "Generated language-neutral attachment client for Volter Harness SDK runtimes",
   "exports": {