@volter/supercode-frontend-vscode 0.1.29 → 0.1.31

package/dist/extension.js

@@ -323,6 +323,7 @@ export async function activate(context) {
     let applying = Promise.resolve();
     let pendingDraft;
     let focusedResource;
+    let focusGeneration = 0;
     const activeDraft = () => pendingDraft?.resource && pendingDraft.resource.toString() === focusedResource?.toString() ? pendingDraft : undefined;
     const draftSelection = () => {
         const choice = activeDraft()?.choice;
@@ -333,8 +334,10 @@ export async function activate(context) {
         focusedResource = resource;
         if (pendingDraft?.resource && pendingDraft.resource.toString() !== resource?.toString())
             pendingDraft = undefined;
-        if (changed)
+        if (changed) {
+            focusGeneration++;
             controlsChanged.fire();
+        }
     };
     const frontends = new SupercodeFrontends();
     // Runtimes attached by address ("Set Runtime Token", "Attach to Runtime")
@@ -388,11 +391,12 @@ export async function activate(context) {
                     const id = `${selection.harness}/${encodeURIComponent(model.id || '__default__')}`;
                     modelSelections.set(id, { ...selection, model: model.id });
                     const provider = runtimeIdentity(selection.harness, selection.model).provider;
-                    return { id, name: model.name, family: selection.harness, version: '1',
+                    const name = model.id ? model.name : runtimeIdentity(selection.harness, model.id).name;
+                    return { id, name, family: selection.harness, version: '1',
                         statusIcon: new vscode.ThemeIcon(provider === 'anthropic' ? 'claude' : provider === 'openai' ? 'openai' : provider === 'google' ? 'google-gemini' : 'sparkle'),
                         maxInputTokens: 0, maxOutputTokens: 0, capabilities: {},
                         targetChatSessionType: SESSION_SCHEME, isUserSelectable: true, isDefault: model.id === selection.model,
-                        tooltip: `${model.name} via ${harnessDisplayName(selection.harness)}${selection.effort ? ` · ${selection.effort} reasoning` : ''}. Model is fixed for this conversation. Use Model settings to choose model and reasoning for a new conversation.`,
+                        tooltip: `${name} via ${harnessDisplayName(selection.harness)}${selection.effort ? ` · ${selection.effort} reasoning` : ''}. Model is fixed for this conversation. Use Model settings to choose model and reasoning for a new conversation.`,
                     };
                 });
             },
@@ -406,11 +410,20 @@ export async function activate(context) {
         const id = resource ? boundId(resource) : controls?.state.activeSession;
         return { permissions: id ? permissions.get(id) ?? 'ask' : permission };
     };
-    const connectManaged = async () => {
-        const env = controls.state.connection;
-        if (!env || !controls.state.activeSession)
+    const savedConnections = new Map();
+    const saveManagedHistory = async (connection) => {
+        const state = await controls.open(connection.id);
+        if (state.activeSession !== connection.id)
+            throw new Error('The conversation changed before its history could be saved.');
+        connection.persistedHistory = state.history;
+        connection.historyTruncated = state.historyTruncated;
+        savedConnections.set(connection.id, connection);
+    };
+    const connectManaged = async (state = controls.state) => {
+        const env = state.connection;
+        if (!env || !state.activeSession)
             throw new Error('The requested conversation has no runtime connection.');
-        const id = controls.state.activeSession;
+        const id = state.activeSession;
         const existing = frontends.get(id);
         if (existing && existing.baseUrl === env.SUPERCODE_FRONTEND_URL && existing.session.connection !== 'closed') {
             if (existing.session.connection !== 'connected')
@@ -421,7 +434,7 @@ export async function activate(context) {
             await frontends.disconnect(connection.id);
         const connection = await frontends.connect({ connectionId: id, baseUrl: env.SUPERCODE_FRONTEND_URL,
             token: await readCredentialFile(env.SUPERCODE_FRONTEND_CREDENTIAL_FILE), clientId: env.SUPERCODE_FRONTEND_CLIENT_ID,
-            permissions: normalizePermissions(env.SUPERCODE_FRONTEND_PERMISSIONS, ['observe']), label: runtimeIdentity(controls.state.selection.harness, controls.state.selection.model || controls.state.actualModel).name }, log);
+            permissions: normalizePermissions(env.SUPERCODE_FRONTEND_PERMISSIONS, ['observe']), label: runtimeIdentity(state.selection.harness, state.selection.model || state.actualModel).name }, log);
         if (!connection)
             throw new Error('Could not connect to the requested conversation.');
         return connection;
@@ -458,17 +471,20 @@ export async function activate(context) {
     };
     let refreshingSetup;
     const refreshSetup = () => {
-        refreshingSetup ??= (async () => {
+        if (refreshingSetup)
+            return refreshingSetup;
+        const pending = applying.then(async () => {
             if (!controls)
                 return;
             // Discover and publish readiness even while a blank chat holds a draft.
             // Only the automatic reveal is suppressed; discovery must never stall.
             await controls.refresh();
+            const state = controls.state;
             controlsChanged.fire();
             const preserveDraft = focusedResource?.path.startsWith('/untitled-');
-            if (controls.state.setup?.ready) {
+            if (state.setup?.ready) {
                 setupRevealed = false;
-                await connectManaged();
+                await connectManaged(state);
                 controlsChanged.fire();
                 if (!preserveDraft && !setupHandoffComplete())
                     await revealManaged();
@@ -479,7 +495,9 @@ export async function activate(context) {
                 if (!preserveDraft)
                     await revealSetup();
             }
-        })().finally(() => { refreshingSetup = undefined; });
+        });
+        applying = pending.then(() => undefined, () => undefined);
+        refreshingSetup = pending.finally(() => { refreshingSetup = undefined; });
         return refreshingSetup;
     };
     const setupTerminals = new Map();
@@ -512,8 +530,8 @@ export async function activate(context) {
         setupTerminals.set(key, terminal);
         terminal.show();
     }));
-    const connectionFor = async (resource) => {
-        focusSession(resource);
+    const restoring = new Map();
+    const connectionFor = async (resource, activate = true) => {
         if (!controls) {
             const connection = frontends.get(resource.authority);
             if (!connection)
@@ -521,7 +539,7 @@ export async function activate(context) {
             return connection;
         }
         const attached = attachedIds.has(resource.authority) ? frontends.get(resource.authority) : undefined;
-        if (focusedAttached !== attached) {
+        if (activate && focusedAttached !== attached) {
             focusedAttached = attached;
             controlsChanged.fire();
         }
@@ -530,26 +548,55 @@ export async function activate(context) {
         const id = boundId(resource);
         if (!id)
             throw new Error('This chat has no backend session binding. Start a new chat; no message was sent.');
-        const active = managed();
-        if (active && active.id !== id && (active.session.descriptor?.turn_state === 'busy' || active.session.pendingRequests.size))
-            throw new Error('Finish or cancel the active turn before opening another conversation.');
+        // Content refresh is not a focus change. Replaying a previously connected
+        // conversation must not retire the runtime the person just selected.
+        if (!activate) {
+            const saved = frontends.get(id) ?? savedConnections.get(id);
+            if (saved)
+                return saved;
+        }
+        const existing = restoring.get(id);
+        // Coalesce adjacent requests only. A later A after a queued B must still
+        // activate A last, rather than borrowing an earlier A's completion.
+        if (existing?.completion === applying)
+            return existing.pending;
+        const pending = applying.then(async () => {
+            const active = managed();
+            if (active && active.id !== id && (active.session.descriptor?.turn_state === 'busy' || active.session.pendingRequests.size))
+                throw new Error('Finish or cancel the active turn before opening another conversation.');
+            if (active && active.id !== id) {
+                // Capture the exact saved transcript while its runtime still belongs
+                // to the host. Subsequent background content reads need no activation.
+                await saveManagedHistory(active);
+            }
+            let state;
+            try {
+                state = await controls.open(id);
+            }
+            catch (error) {
+                log.error(`Could not restore conversation ${id}: ${String(error)}`);
+                throw error;
+            }
+            if (state.activeSession !== id)
+                throw new Error('The host did not restore the requested conversation.');
+            const connection = await connectManaged(state);
+            connection.persistedHistory = state.history;
+            connection.historyTruncated = state.historyTruncated;
+            savedConnections.set(id, connection);
+            if (active !== connection)
+                controlsChanged.fire();
+            return connection;
+        });
+        const completion = pending.then(() => undefined, () => undefined);
+        restoring.set(id, { pending, completion });
+        applying = completion;
         try {
-            await controls.open(id);
+            return await pending;
         }
-        catch (error) {
-            log.error(`Could not restore conversation ${id}: ${String(error)}`);
-            throw error;
+        finally {
+            if (restoring.get(id)?.pending === pending)
+                restoring.delete(id);
         }
-        const history = controls.state.history;
-        const historyTruncated = controls.state.historyTruncated;
-        const connection = await connectManaged();
-        connection.persistedHistory = history;
-        connection.historyTruncated = historyTruncated;
-        // Resolving an already-focused session must not republish its catalogue
-        // while the native widget is still opening that same resource.
-        if (active !== connection)
-            controlsChanged.fire();
-        return connection;
     };
     async function applySelection(selection) {
         if (!controls)
@@ -557,9 +604,12 @@ export async function activate(context) {
         const active = managed();
         if (active?.session.descriptor?.turn_state === 'busy' || active?.session.pendingRequests.size)
             throw new Error('Finish or cancel the current turn before starting a new chat.');
-        await controls.select(selection);
-        await connectManaged();
+        if (active)
+            await saveManagedHistory(active);
+        const state = await controls.select(selection);
+        const connection = await connectManaged(state);
         controlsChanged.fire();
+        return connection;
     }
     const openNewChat = async () => {
         if (!controls || !granted.has('chatSessionsProvider'))
@@ -578,6 +628,7 @@ export async function activate(context) {
         const draft = { resource: vscode.Uri.from({ scheme: SESSION_SCHEME, path: `/untitled-${randomUUID()}` }) };
         pendingDraft = draft;
         focusedResource = draft.resource;
+        focusGeneration++;
         focusedAttached = undefined;
         controlsChanged.fire();
         await vscode.commands.executeCommand(controls.state.openSessionCommand, draft.resource.toString());
@@ -672,9 +723,8 @@ export async function activate(context) {
             const selection = choice?.kind === 'agent' ? choice.selection
                 : { harness: loginHarness ?? controls.state.selection.harness, model: '', effort: '' };
             const pending = applying.then(() => applySelection(selection));
-            applying = pending.catch(() => undefined);
-            await pending;
-            const connection = frontends.get(controls.state.activeSession);
+            applying = pending.then(() => undefined, () => undefined);
+            const connection = await pending;
             savePermission(connection.id, turnPermission(inputState.groups.find(group => group.id === 'permissions')?.selected?.id));
             if (pendingDraft === draft) {
                 pendingDraft = undefined;
@@ -682,8 +732,7 @@ export async function activate(context) {
             }
             return connection;
         },
-        resolve: connectionFor,
-        focus: focusSession,
+        resolve: (resource) => connectionFor(resource, false),
         attached: (connection) => attachedIds.has(connection.id),
         catalogue: () => controls?.state.sessions ?? [],
         bindings: boundId,
@@ -695,7 +744,12 @@ export async function activate(context) {
         focusSession(resource ? vscode.Uri.parse(resource) : undefined);
     }));
     context.subscriptions.push(vscode.commands.registerCommand('supercode.frontend.openSession', async (id) => {
-        await connectionFor(vscode.Uri.from({ scheme: SESSION_SCHEME, authority: id, path: '/conversation' }));
+        const resource = vscode.Uri.from({ scheme: SESSION_SCHEME, authority: id, path: '/conversation' });
+        focusSession(resource);
+        const generation = focusGeneration;
+        await connectionFor(resource);
+        if (generation !== focusGeneration)
+            return;
         await revealManaged();
     }));
     context.subscriptions.push(vscode.commands.registerCommand('supercode.frontend.configure', async (supplied) => {
@@ -945,7 +999,28 @@ export async function activate(context) {
                     p.iconPath = icon();
             };
             context.subscriptions.push({ dispose: () => sessionParticipant.dispose() }, controlsChanged.event(updateIdentity), frontends.onDidChange(updateIdentity));
-            registerSessions(context, frontends, sessionParticipant, granted, handler, controls ? providerControls : undefined);
+            // Replayed turns outlive the active composer participant. Keep their
+            // author tied to the saved harness, including passive background loads.
+            const historyParticipants = new Map();
+            const historyParticipant = (connection) => {
+                if (!granted.has('chatParticipantPrivate'))
+                    return sessionParticipant.id;
+                const harness = connection.session.descriptor?.source_harness
+                    ?? controls?.state.sessions.find(entry => entry.id === connection.id)?.selection.harness;
+                if (!harness)
+                    return sessionParticipant.id;
+                let author = historyParticipants.get(harness);
+                if (!author) {
+                    const name = harnessDisplayName(harness);
+                    author = vscode.chat.createDynamicChatParticipant(`${SESSION_SCHEME}.history.${encodeURIComponent(harness)}`, { name: name.replace(/[^a-zA-Z0-9]/g, ''), fullName: name, publisherName: 'Volter' }, handler);
+                    const provider = runtimeIdentity(harness, '').provider;
+                    author.iconPath = provider ? vscode.Uri.joinPath(context.extensionUri, 'media', `${provider}.svg`) : new vscode.ThemeIcon('hubot');
+                    historyParticipants.set(harness, author);
+                    context.subscriptions.push(author);
+                }
+                return author.id;
+            };
+            registerSessions(context, frontends, sessionParticipant, granted, handler, historyParticipant, controls ? providerControls : undefined);
         }
         catch (error) {
             log.warn(`Volter Harness chat sessions were not registered: ${String(error?.message ?? error)}`);
@@ -1315,7 +1390,7 @@ function applyTiming(item, connection) {
         lastRequestEnded: connection.session.lastTurnEndedMs ?? undefined,
     };
 }
-function registerSessions(context, frontends, participant, granted, handler, controls) {
+function registerSessions(context, frontends, participant, granted, handler, historyParticipant, controls) {
     const turns = vscode;
     const items = () => {
         return (controls?.catalogue() ?? []).filter(entry => !frontends.get(entry.id)).map(entry => {
@@ -1369,12 +1444,15 @@ function registerSessions(context, frontends, participant, granted, handler, con
         }));
     }
     context.subscriptions.push(vscode.chat.registerChatSessionContentProvider(SESSION_SCHEME, {
-        provideChatSessionContent: async (resource, _token, { inputState }) => {
-            controls?.focus(resource);
+        provideChatSessionContent: async (resource, token, { inputState }) => {
+            if (token.isCancellationRequested)
+                throw new vscode.CancellationError();
             const boundHandler = (request, chatContext, stream, token) => handler(request, { ...chatContext, chatSessionContext: { chatSessionItem: { resource, label: 'Conversation' } } }, stream, token);
             // Only a native untitled resource can create a conversation. Existing
             // resources must resolve their exact saved binding; there is no fallback.
             const connection = controls ? (resource.path.startsWith('/untitled-') && !controls.bindings(resource) ? undefined : await controls.resolve(resource)) : frontends.get(resource.authority);
+            if (token.isCancellationRequested)
+                throw new vscode.CancellationError();
             if (!connection) {
                 return { history: [], requestHandler: boundHandler };
             }
@@ -1387,13 +1465,14 @@ function registerSessions(context, frontends, participant, granted, handler, con
             // `state.history`), so the copy taken when this window attached is
             // stale as soon as a turn runs. The generated client reuses the
             // already-open event stream, so this is a snapshot, not a reconnect.
-            const attached = await connection.session.attach().then(() => true).catch(() => {
+            const attached = frontends.get(connection.id) === connection && await connection.session.attach().then(() => true).catch(() => {
                 // An unreachable runtime replays what this window last saw.
                 return false;
             });
             // The attach snapshot IS the session's history: the runtime's own
             // canonical transcript, replayed as turns.
             const history = [];
+            const authorId = historyParticipant(connection);
             // A hosted harness runtime has no canonical ChatMessage history —
             // `HostedHarnessRuntime::attach` returns an empty one and puts the
             // conversation in `replay`. Read whichever the runtime actually
@@ -1419,13 +1498,13 @@ function registerSessions(context, frontends, participant, granted, handler, con
                     canRespond: connection.session.descriptor?.actions.respond !== false,
                 });
             if (connection.historyTruncated)
-                history.push(new turns.ChatRequestTurn('[Earlier conversation history]', undefined, [], participant.id, []), new turns.ChatResponseTurn([new vscode.ChatResponseMarkdownPart('_Showing the latest 120 saved messages. Earlier context remains in the harness session._')], {}, participant.id));
+                history.push(new turns.ChatRequestTurn('[Earlier conversation history]', undefined, [], authorId, []), new turns.ChatResponseTurn([new vscode.ChatResponseMarkdownPart('_Showing the latest 120 saved messages. Earlier context remains in the harness session._')], {}, authorId));
             for (const turn of projected) {
                 if (turn.role === 'user') {
-                    history.push(new turns.ChatRequestTurn(turn.prompt ?? '', undefined, [], participant.id, []));
+                    history.push(new turns.ChatRequestTurn(turn.prompt ?? '', undefined, [], authorId, []));
                     continue;
                 }
-                history.push(new turns.ChatResponseTurn(historyParts(oneRowPerToolCall(turn.parts ?? [])), {}, participant.id));
+                history.push(new turns.ChatResponseTurn(historyParts(oneRowPerToolCall(turn.parts ?? [])), {}, authorId));
             }
             const busy = connection.session.descriptor?.turn_state === 'busy';
             return {

package/dist/host-controls.d.ts

@@ -55,6 +55,7 @@ export declare class ChatHostControls {
     readonly baseUrl: string;
     private readonly credential;
     state: HostState;
+    private updating;
     private constructor();
     static fromEnvironment(env?: NodeJS.ProcessEnv): Promise<ChatHostControls | undefined>;
     refresh(): Promise<void>;
@@ -67,6 +68,9 @@ export declare class ChatHostControls {
         arguments: string[];
         env?: Record<string, string>;
     }>;
+    /** Publish complete host replies in request order; a late refresh must not
+     * overwrite the connection returned by a newer lifecycle operation. */
+    private update;
     private request;
 }
 /** Approval policy is captured for one turn, never inferred from connection privileges. */

package/dist/host-controls.js

@@ -3,6 +3,7 @@ export class ChatHostControls {
     baseUrl;
     credential;
     state;
+    updating = Promise.resolve();
     constructor(baseUrl, credential, state) {
         this.baseUrl = baseUrl;
         this.credential = credential;
@@ -19,21 +20,28 @@ export class ChatHostControls {
         host.state = await host.request('/state');
         return host;
     }
-    async refresh() { this.state = await this.request('/state'); }
+    async refresh() { await this.update('/state'); }
     async select(selection) {
-        const result = await this.request('/select', selection);
-        this.state = result;
-        return result;
+        return this.update('/select', selection);
     }
-    async remember(id, nativeId) { this.state = await this.request('/remember', { id, nativeId }); }
+    async remember(id, nativeId) { await this.update('/remember', { id, nativeId }); }
     async open(id) {
-        const result = await this.request('/open', { id });
-        this.state = result;
-        return result;
+        return this.update('/open', { id });
     }
     async setup(kind, harness) {
         return this.request('/setup', { kind, harness });
     }
+    /** Publish complete host replies in request order; a late refresh must not
+     * overwrite the connection returned by a newer lifecycle operation. */
+    update(path, selection) {
+        const pending = this.updating.then(async () => {
+            const result = await this.request(path, selection);
+            this.state = result;
+            return result;
+        });
+        this.updating = pending.then(() => undefined, () => undefined);
+        return pending;
+    }
     async request(path, selection) {
         const response = await fetch(this.baseUrl + path, {
             method: selection ? 'POST' : 'GET', headers: { Authorization: `Bearer ${this.credential}`, 'Content-Type': 'application/json' },

package/package.json

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