@volter/supercode-frontend-vscode 0.1.36 → 0.1.37

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

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. */
@@ -739,6 +741,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.');
@@ -880,13 +920,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 +939,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,31 +965,24 @@ 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() });
@@ -977,20 +1018,29 @@ 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));
+        let completed = false;
         try {
             await connection.session.runTurn(prompt, (event) => {
                 writeProjected(stream, projectEvent(event, projection), granted, state);
                 sweep();
             });
+            completed = true;
         }
         finally {
             sweeps.delete(sweep);
@@ -1003,6 +1053,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) => {

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.37",
   "type": "module",
   "description": "VS Code chat-view frontend for an existing Volter Harness SDK runtime",
   "publisher": "volter-ai-dev",