@volter/supercode-frontend-vscode 0.1.36 → 0.1.38

package/README.md

@@ -94,9 +94,11 @@ which startable agent to use. It refreshes the host's available choices first;
 with one ready local agent and no pending native sign-in choices it opens
 immediately, even when the official ChatGPT choice is available. Otherwise the
 picker includes the official choice on supported hosts; with no choices it returns
-to setup. Model
-and reasoning are sent as empty values, leaving both at the harness's own defaults,
-even if the previous conversation used explicit settings. Cancelling the agent
+to setup. Picking an agent sends model
+and reasoning as empty values, leaving both at the harness's own defaults,
+even if the previous conversation used explicit settings. Each agent whose model
+and reasoning a chat can set (Claude Code, Codex) is also listed in the picker as **<agent>: model
+and reasoning…**, which goes on to the model and effort choices below. Cancelling the agent
 picker starts no backend conversation.
 
 The native blank chat opens before the picker appears. First send waits for the
@@ -116,8 +118,14 @@ sign-in choice it uses that agent once ready, otherwise it keeps the draft with
 a visible sign-in error.
 
 The composer's native **Model settings** control offers **Choose model and reasoning
-for a new chat…** for Claude Code and Codex. This optional path retains the model
-list, exact model ID entry and reasoning choices. Only completing the choices
+for a new chat…** for Claude Code and Codex, and **Chat: Model and Reasoning: Open New
+Chat** does the same from anywhere (with no conversation open it asks for the agent
+first). The models and each model's reasoning efforts are the host's
+`modelsByHarness` choices, which a host reads from the harness itself (Model Editor:
+Claude Code's `--help`, Codex's models cache), so levels such as `xhigh` and `max`
+appear as the harness offers them; a host that sends no efforts gets low/medium/high.
+Exact model ID entry remains. When a turn ends, its reply notes the model it ran on
+(as the harness's replies name it) and the effort it was given. Only completing the choices
 configures the new blank chat; its backend starts on first send. Cancelling a
 choice starts no backend and leaves the blank chat available.
 A conversation's harness, model and reasoning remain fixed: this integration does
@@ -152,7 +160,8 @@ default is never stored as a choice (a pick equal to the default follows the def
 changes), and an Auto approve is never stored for a conversation that cannot answer. Conversations opened before 0.1.36 saved their picker's
 **Ask** when opened and keep it. Auto approve approves the requests the harness would ask you about, including requests to run
 outside its sandbox (Codex's approval requests are its sandbox escalations); the harness's deny
-rules still apply. Each request it answers is noted in the turn ("auto-approved: …"). Unsupported modes are refused. Unanswerable
+rules still apply. Each request it answers is noted in the turn ("auto-approved: …"). A turn
+re-joined after a page reload (the conversation's active response) is answered the same way. Unsupported modes are refused. Unanswerable
 harnesses show **Harness permissions**. Previously answered requests cannot affect another
 connection. Native command-button fallback limitations are documented below.
 

package/dist/extension.js

@@ -11,6 +11,8 @@ import { observeActiveResponse, sessionStatus } from './native-session.js';
 import { RequestNotPendingError, VscodeFrontendSession } from './session.js';
 import { acceptedDecisions, opaqueText, projectEvent, projectPendingRequests, projectHistory, projectReplayTurns, resolveParts, resolutionSentence, typedAnswer, } from './view.js';
 const SESSION_SCHEME = 'supercode';
+/** The harnesses whose model and reasoning effort a new chat can set (the host passes them to the CLI). */
+const CONFIGURABLE_HARNESSES = ['claude-code', 'codex'];
 const PARTICIPANT_ID = 'supercode.chat';
 const DEFAULT_PARTICIPANT_ID = 'supercode.chat.default';
 /** `package.json` gates the `isDefault` participant on this key. */
@@ -367,6 +369,7 @@ export async function activate(context) {
     };
     // The approval sweeps of each conversation's running turns, so a picker change reaches a turn already running.
     const runningTurns = new Map();
+    const answeredRequests = new Map();
     // The host's default for a conversation no one has chosen for (Model Editor declares Auto approve).
     const hostDefault = () => controls?.state.defaultPermission === 'autoApprove' ? 'autoApprove' : 'ask';
     const canAnswer = (connection) => Boolean(connection.session.descriptor?.actions.respond && connection.session.permissions.has('approve'));
@@ -739,6 +742,44 @@ export async function activate(context) {
             throw new vscode.CancellationError();
         return draft;
     };
+    // A new chat's model and reasoning effort, offered from what the harness itself lists (the host reads its models
+    // and each model's efforts from the harness). Escape cancels; "Harness default" passes nothing, so the harness's
+    // own settings decide. A host that sends no efforts gets the levels every configurable harness takes.
+    // A single pick that opens on the current value (showQuickPick's `picked` applies only to multi-select).
+    const pickWithCurrent = (items, title, placeholder, currentId) => {
+        const quick = vscode.window.createQuickPick();
+        quick.title = title;
+        quick.placeholder = placeholder;
+        quick.items = items;
+        quick.activeItems = items.filter(item => item.id === currentId);
+        return new Promise(resolve => {
+            quick.onDidAccept(() => resolve(quick.selectedItems[0]));
+            quick.onDidHide(() => resolve(undefined));
+            quick.show();
+        }).finally(() => quick.dispose());
+    };
+    const pickModelAndEffort = async (harness, current) => {
+        const choices = controls?.state.modelsByHarness?.[harness] ?? [{ id: '', name: 'Harness default' }];
+        const name = harnessDisplayName(harness);
+        const items = [...choices.map(model => ({ label: model.name, description: [model.id, model.description].filter(Boolean).join(' · ') || undefined, id: model.id, efforts: model.efforts })),
+            { label: 'Enter an exact model ID…', description: undefined, id: '__custom__', efforts: choices.find(model => model.id === '')?.efforts }];
+        const picked = await pickWithCurrent(items, `New chat · ${name} model`, 'Model availability depends on your harness account.', current?.model ?? '');
+        if (!picked)
+            return;
+        let model = picked.id;
+        if (picked.id === '__custom__') {
+            const typed = await vscode.window.showInputBox({ title: `New chat · ${name} exact model`, prompt: 'Model ID or CLI alias supported by this harness account.', value: current?.model });
+            if (typed === undefined)
+                return;
+            model = typed.trim();
+        }
+        const levels = picked.efforts ?? ['low', 'medium', 'high'];
+        const efforts = [{ label: 'Harness default', id: '' }, ...levels.map(id => ({ label: id, id }))];
+        const effort = levels.length === 0 ? efforts[0] : await pickWithCurrent(efforts, `New chat · ${name} reasoning effort`, model ? `For ${model}` : 'For the harness default model', current?.effort ?? '');
+        if (!effort)
+            return;
+        return { model, effort: effort.id };
+    };
     const chooseNewChat = async (pick) => {
         if (pendingDraft?.choosing)
             throw new Error('Finish choosing an agent before starting another chat.');
@@ -842,6 +883,7 @@ export async function activate(context) {
         attached: (connection) => attachedIds.has(connection.id),
         catalogue: () => controls?.state.sessions ?? [],
         bindings: boundId,
+        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)); }));
     // The host's native focus event is authoritative even when a cached model
@@ -880,13 +922,17 @@ export async function activate(context) {
         // Sign-in choices stay visible alongside agents that can be explicitly started.
         const login = controls.state.setup?.actions.filter(action => action.kind === 'login') ?? [];
         const localChoices = [
-            ...login.map(action => ({ label: action.name, id: action.harness, description: 'Sign in…', login: true, autoStart: false })),
+            ...login.map(action => ({ label: action.name, id: action.harness, description: 'Sign in…', login: true, autoStart: false, configure: false })),
             ...controls.state.harnesses.filter(h => !login.some(action => action.harness === h.id))
-                .map(h => ({ label: h.name, id: h.id, description: h.description, login: false, autoStart: h.autoStart === true })),
+                .map(h => ({ label: h.name, id: h.id, description: h.description, login: false, autoStart: h.autoStart === true, configure: false })),
         ];
+        // Each agent whose model and reasoning a chat can set also offers that, right where the agent is chosen.
+        const modelChoices = localChoices.filter(choice => !choice.login && CONFIGURABLE_HARNESSES.includes(choice.id))
+            .map(choice => ({ ...choice, label: `${choice.label}: model and reasoning…`, description: 'Choose the model and reasoning effort', autoStart: false, configure: true }));
         const choices = [
-            ...(offerChatGPT ? [{ label: 'Sign in with ChatGPT', id: CHATGPT_SIGN_IN, description: 'Official Codex extension', login: false, autoStart: false }] : []),
+            ...(offerChatGPT ? [{ label: 'Sign in with ChatGPT', id: CHATGPT_SIGN_IN, description: 'Official Codex extension', login: false, autoStart: false, configure: false }] : []),
             ...localChoices,
+            ...modelChoices,
         ];
         if (!choices.length) {
             await revealSetup();
@@ -895,9 +941,13 @@ export async function activate(context) {
         // A sole sign-in option still requires a deliberate click before opening its terminal.
         // The official choice must not disable the existing sole-local-agent shortcut.
         await chooseNewChat(async () => {
-            const harness = localChoices.length === 1 && localChoices[0].autoStart ? localChoices[0] : await vscode.window.showQuickPick(choices, { title: 'New chat · Agent', placeHolder: 'Choose your coding agent. Model and reasoning use its defaults.' });
+            const harness = localChoices.length === 1 && localChoices[0].autoStart ? localChoices[0] : await vscode.window.showQuickPick(choices, { title: 'New chat · Agent', placeHolder: 'Choose your coding agent. Its default model and reasoning apply unless you choose them.' });
             if (!harness)
                 return { kind: 'cancelled' };
+            if (harness.configure) {
+                const chosen = await pickModelAndEffort(harness.id);
+                return chosen ? { kind: 'agent', selection: { harness: harness.id, ...chosen } } : { kind: 'cancelled' };
+            }
             if (harness.id === CHATGPT_SIGN_IN) {
                 await vscode.commands.executeCommand(CHATGPT_SIGN_IN);
                 return { kind: 'signIn' };
@@ -917,53 +967,36 @@ export async function activate(context) {
         const bound = resource ? boundId(resource) : undefined;
         if (resource && (!bound || (sessionId && bound !== sessionId)))
             throw new Error('Model settings have no matching conversation binding.');
-        const id = bound ?? controls.state.activeSession;
-        const selected = controls.state.sessions.find(session => session.id === id);
-        if (!selected || selected.id !== controls.state.activeSession)
-            throw new Error('Open this conversation before choosing model settings.');
-        const selection = { ...selected.selection };
-        if (!['claude-code', 'codex'].includes(selection.harness))
-            throw new Error('This harness uses its own model defaults; configuration is not advertised.');
+        // The conversation it was opened from sets the agent and the current values; with none open (a fresh project,
+        // the command palette) the person picks the agent first. Either way the choice opens a new chat.
+        const selected = controls.state.sessions.find(session => session.id === (bound ?? controls.state.activeSession));
+        // An agent that still needs sign-in is set up from the agent picker first, as there.
+        const needsSignIn = new Set((controls.state.setup?.actions ?? []).filter(action => action.kind === 'login').map(action => action.harness));
+        const configurable = controls.state.harnesses.filter(harness => CONFIGURABLE_HARNESSES.includes(harness.id) && !needsSignIn.has(harness.id));
+        if (!configurable.length && !(selected && CONFIGURABLE_HARNESSES.includes(selected.selection.harness)))
+            throw new Error('No agent on this machine takes a model or reasoning choice here; its own defaults apply.');
         await chooseNewChat(async () => {
-            const choices = controls.state.modelsByHarness?.[selection.harness] ?? [{ id: '', name: 'Harness default' }];
-            const picked = await vscode.window.showQuickPick([...choices.map(model => ({ label: model.name, id: model.id })), { label: 'Enter an exact model ID…', id: '__custom__' }], { title: 'New chat · Model', placeHolder: 'Model availability depends on your harness account.' });
-            if (!picked)
-                return { kind: 'cancelled' };
-            if (picked.id === '__custom__') {
-                const model = await vscode.window.showInputBox({ title: 'New chat · Exact model', prompt: 'Model ID or CLI alias supported by this harness account.', value: selection.model });
-                if (model === undefined)
+            let harness = selected && CONFIGURABLE_HARNESSES.includes(selected.selection.harness) ? selected.selection.harness : undefined;
+            if (!harness) {
+                const agent = configurable.length === 1 ? configurable[0] : await vscode.window.showQuickPick(configurable.map(choice => ({ ...choice, label: choice.name })), { title: 'New chat · Agent', placeHolder: 'Choose the agent whose model and reasoning to set.' });
+                if (!agent)
                     return { kind: 'cancelled' };
-                selection.model = model.trim();
+                harness = agent.id;
             }
-            else
-                selection.model = picked.id;
-            const effort = await vscode.window.showQuickPick([{ label: 'Harness default', id: '' }, ...['low', 'medium', 'high'].map(id => ({ label: id, id }))], { title: 'New chat · Reasoning effort' });
-            if (!effort)
-                return { kind: 'cancelled' };
-            selection.effort = effort.id;
-            return { kind: 'agent', selection };
+            const chosen = await pickModelAndEffort(harness, selected?.selection.harness === harness ? selected.selection : undefined);
+            return chosen ? { kind: 'agent', selection: { harness, ...chosen } } : { kind: 'cancelled' };
         });
     }));
     context.subscriptions.push({ dispose: () => frontends.dispose() });
-    const runTurnInto = async (connection, prompt, stream, token, approval) => {
-        if (approval() === 'autoApprove' && !canAnswer(connection)) {
-            throw new Error('This harness does not support automatic approval through Chat. Select Harness permissions.');
-        }
-        const answered = new Set();
-        const state = { toolInputs: new Map(), toolNames: new Map() };
-        const projection = {
-            connectionId: connection.id,
-            pendingRequest: (requestId) => connection.session.pendingRequests.get(requestId) ?? connection.session.resolvedRequests.get(requestId),
-            canRespond: connection.session.descriptor?.actions.respond !== false,
-        };
-        const cancellation = token.onCancellationRequested(() => {
-            void connection.session.interrupt().catch(() => {
-                // The runtime may already be idle; interrupting twice is not an error
-                // this view reports.
-            });
-        });
-        // Read at every event and on every picker change, so switching to Auto approve mid-turn
-        // answers the approvals already waiting and the ones after them.
+    // Auto-answers a conversation's approvals while a response is written into `stream`: read at every event
+    // (`sweep`) and on every picker change for that conversation, so switching to Auto approve mid-turn answers
+    // the approvals already waiting and the ones after them. Used by a turn this window runs and by a turn it
+    // re-joins after a reload (the session's active response), whose original handler is gone.
+    const watchApprovals = (connection, stream, token, approval) => {
+        // One answered set per conversation, shared by every watch on it, so a re-joined response and a live turn
+        // never both answer the same request (the second answer would be refused and noted as a failure).
+        const answered = answeredRequests.get(connection.id) ?? new Set();
+        answeredRequests.set(connection.id, answered);
         const sweep = () => {
             if (approval() !== 'autoApprove' || token.isCancellationRequested || !canAnswer(connection))
                 return;
@@ -977,25 +1010,57 @@ export async function activate(context) {
                 // Its card is already in the stream (the event that raised it was written first), so say it was answered.
                 const payload = pending.payload && typeof pending.payload === 'object' && !Array.isArray(pending.payload) ? pending.payload : {};
                 const named = [payload.title, payload.tool, payload.tool_name].find((value) => typeof value === 'string');
+                // The answer can settle after the turn's response has closed, when writing to it throws: the note is then dropped.
+                const note = (text) => { try {
+                    stream.markdown(text);
+                }
+                catch {
+                    log.info(text.trim());
+                } };
                 void connection.session.respond({ kind: 'approval', request_id: pending.id, decision: 'allow' }).then(() => {
-                    stream.markdown(`\n_auto-approved: ${opaqueText(named ?? `request #${pending.id}`, 200)}_\n`);
+                    note(`\n_auto-approved: ${opaqueText(named ?? `request #${pending.id}`, 200)}_\n`);
                 }, error => {
-                    stream.markdown(`\nApproval failed: ${String(error.message || error)}. Use the approval buttons to answer.\n`);
+                    note(`\nApproval failed: ${String(error.message || error)}. Use the approval buttons to answer.\n`);
                 });
             }
         };
         const sweeps = runningTurns.get(connection.id) ?? new Set();
         runningTurns.set(connection.id, sweeps.add(sweep));
+        return { sweep, dispose: () => {
+                sweeps.delete(sweep);
+                if (!sweeps.size && runningTurns.get(connection.id) === sweeps) {
+                    runningTurns.delete(connection.id);
+                    answeredRequests.delete(connection.id);
+                }
+            } };
+    };
+    const runTurnInto = async (connection, prompt, stream, token, approval) => {
+        if (approval() === 'autoApprove' && !canAnswer(connection)) {
+            throw new Error('This harness does not support automatic approval through Chat. Select Harness permissions.');
+        }
+        const state = { toolInputs: new Map(), toolNames: new Map() };
+        const projection = {
+            connectionId: connection.id,
+            pendingRequest: (requestId) => connection.session.pendingRequests.get(requestId) ?? connection.session.resolvedRequests.get(requestId),
+            canRespond: connection.session.descriptor?.actions.respond !== false,
+        };
+        const cancellation = token.onCancellationRequested(() => {
+            void connection.session.interrupt().catch(() => {
+                // The runtime may already be idle; interrupting twice is not an error
+                // this view reports.
+            });
+        });
+        const watch = watchApprovals(connection, stream, token, approval);
+        let completed = false;
         try {
             await connection.session.runTurn(prompt, (event) => {
                 writeProjected(stream, projectEvent(event, projection), granted, state);
-                sweep();
+                watch.sweep();
             });
+            completed = true;
         }
         finally {
-            sweeps.delete(sweep);
-            if (!sweeps.size && runningTurns.get(connection.id) === sweeps)
-                runningTurns.delete(connection.id);
+            watch.dispose();
             cancellation.dispose();
             if (controls && !attachedIds.has(connection.id)) {
                 if (connection.session.descriptor?.session_id)
@@ -1003,6 +1068,12 @@ export async function activate(context) {
                 await controls.refresh().catch(error => log.warn(`Could not refresh chat identity: ${String(error)}`));
                 controlsChanged.fire();
             }
+            // The model the turn ran on: what the harness's own replies name (the host watches them), else what the
+            // runtime reports; and the effort it was given.
+            const ran = (controls?.state.activeSession === connection.id ? controls.state.actualModel : undefined) || connection.session.descriptor?.model;
+            const effort = controls?.state.sessions.find(session => session.id === connection.id)?.selection.effort;
+            if (completed && ran && !token.isCancellationRequested)
+                stream.markdown(`\n\n_Ran on ${opaqueText(ran, 120)}${effort ? ` · ${opaqueText(effort, 24)} effort` : ''}_`);
         }
     };
     const handler = async (request, chatContext, stream, token) => {
@@ -1630,18 +1701,29 @@ function registerSessions(context, frontends, participant, granted, handler, his
                 requestHandler: boundHandler,
                 activeResponseCallback: busy
                     ? async (stream, token) => {
-                        const state = { toolInputs: new Map(), toolNames: new Map() };
-                        writeProjected(stream, projectPendingRequests(connection.session.pendingRequests.values(), {
-                            connectionId: connection.id,
-                            canRespond: connection.session.descriptor?.actions.respond !== false,
-                        }), granted, state);
-                        await observeActiveResponse(connection.session, token, (event) => {
-                            writeProjected(stream, projectEvent(event, {
+                        // A turn re-joined after a reload has lost the handler that ran it, so its approvals are
+                        // answered here under the conversation's mode (t_39dac582): Auto approve answers the cards
+                        // already waiting and later ones; Ask leaves them for the person, as before.
+                        const watch = controls && !controls.attached(connection) ? controls.watchApprovals(connection, stream, token) : undefined;
+                        try {
+                            const state = { toolInputs: new Map(), toolNames: new Map() };
+                            writeProjected(stream, projectPendingRequests(connection.session.pendingRequests.values(), {
                                 connectionId: connection.id,
-                                pendingRequest: (id) => connection.session.pendingRequests.get(id) ?? connection.session.resolvedRequests.get(id),
                                 canRespond: connection.session.descriptor?.actions.respond !== false,
                             }), granted, state);
-                        });
+                            watch?.sweep();
+                            await observeActiveResponse(connection.session, token, (event) => {
+                                writeProjected(stream, projectEvent(event, {
+                                    connectionId: connection.id,
+                                    pendingRequest: (id) => connection.session.pendingRequests.get(id) ?? connection.session.resolvedRequests.get(id),
+                                    canRespond: connection.session.descriptor?.actions.respond !== false,
+                                }), granted, state);
+                                watch?.sweep();
+                            });
+                        }
+                        finally {
+                            watch?.dispose();
+                        }
                     }
                     : undefined,
             };

package/dist/host-controls.d.ts

@@ -5,11 +5,13 @@ export interface ChatSelection {
     model: string;
     effort: string;
 }
+/** `efforts`: the reasoning efforts a model takes, as the host read them from the harness (absent from older hosts). */
 export interface ChatChoice {
     id: string;
     name: string;
     description?: string;
     autoStart?: boolean;
+    efforts?: string[];
 }
 export interface ManagedChatSession {
     id: string;

package/package.json

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