@volter/supercode-frontend-vscode 0.1.15 → 0.1.16

package/dist/extension.js

@@ -8,7 +8,7 @@ import { readCredentialFile } from './credential.js';
 import { grantedProposals, PROPOSAL_EFFECTS, REQUESTED_PROPOSALS } from './proposals.js';
 import { observeActiveResponse, sessionStatus } from './native-session.js';
 import { RequestNotPendingError, VscodeFrontendSession } from './session.js';
-import { fence, acceptedDecisions, opaqueText, projectEvent, projectPendingRequests, projectHistory, projectReplayTurns, resolveParts, resolutionSentence, typedAnswer, } from './view.js';
+import { acceptedDecisions, opaqueText, projectEvent, projectPendingRequests, projectHistory, projectReplayTurns, resolveParts, resolutionSentence, typedAnswer, } from './view.js';
 const SESSION_SCHEME = 'supercode';
 const PARTICIPANT_ID = 'supercode.chat';
 const DEFAULT_PARTICIPANT_ID = 'supercode.chat.default';
@@ -324,9 +324,17 @@ export async function activate(context) {
     const boundId = (resource) => resolveSessionBinding(resource, controls?.state.sessions ?? [], resourceBindings);
     let applying = Promise.resolve();
     const frontends = new SupercodeFrontends();
+    // Runtimes attached by address ("Set Runtime Token", "Attach to Runtime")
+    // beside a host's managed conversation. The host's catalogue does not know
+    // them, so they open as what they are: attachments, shown as their runtime
+    // reports them, and never taken for the conversation the host manages.
+    const attachedIds = new Set();
+    const managed = () => frontends.all.find((connection) => !attachedIds.has(connection.id));
+    // The attached runtime the person is looking at: the Chat names its harness, not the host's.
+    let focusedAttached;
     let approvalAvailable = false;
     context.subscriptions.push(frontends.onDidChange(() => {
-        const active = frontends.get(undefined);
+        const active = managed();
         const available = Boolean(active?.session.descriptor?.actions.respond && active.session.permissions.has('approve'));
         if (available !== approvalAvailable) {
             approvalAvailable = available;
@@ -334,7 +342,9 @@ export async function activate(context) {
         }
     }));
     const identity = () => {
-        const descriptor = frontends.get(undefined)?.session.descriptor;
+        if (focusedAttached)
+            return runtimeIdentity(focusedAttached.session.descriptor?.source_harness, focusedAttached.session.descriptor?.model);
+        const descriptor = managed()?.session.descriptor;
         return runtimeIdentity(controls?.state.selection.harness ?? descriptor?.source_harness, controls?.state.selection.model || controls?.state.actualModel || descriptor?.model);
     };
     const icon = () => {
@@ -384,7 +394,8 @@ export async function activate(context) {
         const existing = frontends.get(id);
         if (existing && existing.baseUrl === env.SUPERCODE_FRONTEND_URL)
             return existing;
-        await frontends.disconnect();
+        for (const connection of frontends.all.filter((entry) => !attachedIds.has(entry.id)))
+            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: identity().name }, log);
@@ -405,10 +416,17 @@ export async function activate(context) {
                 throw new Error('This conversation is no longer connected.');
             return connection;
         }
+        const attached = attachedIds.has(resource.authority) ? frontends.get(resource.authority) : undefined;
+        if (focusedAttached !== attached) {
+            focusedAttached = attached;
+            controlsChanged.fire();
+        }
+        if (attached)
+            return attached;
         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 = frontends.get(undefined);
+        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.');
         try {
@@ -432,7 +450,7 @@ export async function activate(context) {
     async function applySelection(selection, openChat = true) {
         if (!controls)
             throw new Error('This host does not expose harness or model configuration.');
-        const active = frontends.get(undefined);
+        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);
@@ -454,7 +472,7 @@ export async function activate(context) {
         currentOptions,
         options: (resource) => {
             const id = resource ? boundId(resource) : undefined;
-            const active = resource ? (id ? frontends.get(id) : undefined) : frontends.get(undefined);
+            const active = resource ? (id ? frontends.get(id) : undefined) : managed();
             const canApprove = active?.session.descriptor?.actions.respond && active.session.permissions.has('approve');
             const permissionItems = [{ id: 'ask', name: canApprove ? 'Ask for approval' : 'Harness permissions', description: canApprove ? 'Show each approval requested by the harness.' : 'Approval controls are unavailable for this harness.' },
                 ...((canApprove || (!active && resource && currentOptions(resource).permissions === 'autoApprove')) ? [{ id: 'autoApprove', name: 'Auto approve', description: 'Allow tool approval requests for this chat. Harness sandbox rules still apply.' }] : [])];
@@ -479,6 +497,7 @@ export async function activate(context) {
             return connection;
         },
         resolve: connectionFor,
+        attached: (connection) => attachedIds.has(connection.id),
         catalogue: () => controls?.state.sessions ?? [],
         bindings: boundId,
     };
@@ -578,7 +597,7 @@ export async function activate(context) {
         }
         finally {
             cancellation.dispose();
-            if (controls) {
+            if (controls && !attachedIds.has(connection.id)) {
                 if (connection.session.descriptor?.session_id)
                     await controls.remember(connection.id, connection.session.descriptor.session_id).catch(error => log.warn(`Could not save conversation identity: ${String(error)}`));
                 await controls.refresh().catch(error => log.warn(`Could not refresh chat identity: ${String(error)}`));
@@ -591,8 +610,8 @@ export async function activate(context) {
         const requestedResource = chatContext.chatSessionContext?.chatSessionItem?.resource;
         const connection = requestedResource
             ? await connectionFor(requestedResource)
-            : controls ? undefined : frontends.get(undefined);
-        if (controls && connection && request.model?.vendor === 'supercode-runtime') {
+            : controls ? undefined : managed();
+        if (controls && connection && !attachedIds.has(connection.id) && request.model?.vendor === 'supercode-runtime') {
             const selection = controls.state.sessions.find(s => s.id === connection.id).selection;
             const expected = `${selection.harness}/${encodeURIComponent(selection.model || '__default__')}`;
             if (request.model.id !== expected || (typeof request.modelConfiguration?.reasoningEffort === 'string' && request.modelConfiguration.reasoningEffort !== selection.effort)) {
@@ -652,7 +671,7 @@ export async function activate(context) {
             // canDelegate is disabled to avoid a generic workbench-owned registration.
             // A participant names the harness; the native model picker names the model.
             // Keep the author stable when a model changes during request dispatch.
-            const participantName = () => harnessDisplayName(controls?.state.selection.harness ?? frontends.get(undefined)?.session.descriptor?.source_harness);
+            const participantName = () => harnessDisplayName(focusedAttached?.session.descriptor?.source_harness ?? controls?.state.selection.harness ?? managed()?.session.descriptor?.source_harness);
             const participantKey = () => `${participantName()}/${identity().provider ?? ''}`;
             const makeParticipant = () => {
                 const current = { name: participantName() };
@@ -792,11 +811,16 @@ export async function activate(context) {
             log.info('Volter Harness: a base URL is configured but no token is stored; run Volter Harness: Set Runtime Token.');
             return;
         }
-        await frontends
+        const connection = await frontends
             .connect({ baseUrl, token, permissions: normalizePermissions(settings.get('permissions'), ['observe']) }, log)
             .catch((error) => {
             log.error(`Volter Harness could not attach to ${baseUrl}: ${String(error?.message ?? error)}`);
+            return undefined;
         });
+        if (controls && connection) {
+            attachedIds.add(connection.id);
+            controlsChanged.fire();
+        }
     }
     /**
      * The handover path: a runtime (or a product that launched this editor's
@@ -903,10 +927,79 @@ export function deactivate() {
     // Every disposable is owned by the extension context.
 }
 /**
- * One rendered part as the markdown a HISTORY turn carries. A replayed turn is
- * built from `ChatResponseMarkdownPart`s only — the live part types belong to a
- * running stream — so a tool row becomes its own one-line summary rather than
- * the JSON of the object that would have drawn it.
+ * A tool call reaches a turn as two parts, its start and its completion, which
+ * a live stream draws as one row because the editor merges them by
+ * `toolCallId`. A HISTORY turn is markdown and merges nothing, so each call
+ * showed twice ("Tool call: exec" and again with its output). The start keeps
+ * its place and its description (the command it ran); the completion gives it
+ * its output and outcome.
+ */
+function oneRowPerToolCall(parts) {
+    const rows = [];
+    const started = new Map();
+    for (const part of parts) {
+        if (part.part === 'tool' && part.toolCallId) {
+            const at = started.get(part.toolCallId);
+            const first = at === undefined ? undefined : rows[at];
+            if (first && first.part === 'tool' && part.isComplete) {
+                rows[at] = {
+                    ...first,
+                    ...part,
+                    pastTenseMessage: first.invocationMessage ?? part.pastTenseMessage,
+                    invocationMessage: first.invocationMessage ?? part.invocationMessage,
+                };
+                continue;
+            }
+            if (!part.isComplete)
+                started.set(part.toolCallId, rows.length);
+        }
+        rows.push(part);
+    }
+    return rows;
+}
+/**
+ * A saved turn's parts, drawn as the live stream draws them. The editor
+ * converts a history turn's response with the same converter as a live
+ * response (`convertResponseTurn` maps every part through it), so a tool call
+ * is the same `ChatToolInvocationPart` row it was while it ran; only the text
+ * between tools is markdown, consecutive text joined into one part. A turn
+ * looks the same however late the Chat was opened.
+ */
+function historyParts(parts) {
+    const out = [];
+    let text = [];
+    const flush = () => {
+        if (text.length)
+            out.push(new vscode.ChatResponseMarkdownPart(text.join('\n\n')));
+        text = [];
+    };
+    for (const part of parts) {
+        if (part.part === 'tool') {
+            flush();
+            const toolName = part.toolName || 'tool';
+            const invocation = new vscode.ChatToolInvocationPart(toolName, part.toolCallId);
+            invocation.invocationMessage = part.invocationMessage || toolName;
+            invocation.pastTenseMessage = part.pastTenseMessage || part.invocationMessage || toolName;
+            invocation.isConfirmed = true;
+            invocation.isComplete = part.isComplete;
+            if (part.isError !== undefined)
+                invocation.isError = part.isError;
+            if (part.isComplete) {
+                invocation.toolSpecificData = { input: part.inputText ?? '', output: part.resultText ?? '' };
+            }
+            out.push(invocation);
+            continue;
+        }
+        const value = historyText(part);
+        if (value)
+            text.push(value);
+    }
+    flush();
+    return out.length ? out : [new vscode.ChatResponseMarkdownPart('')];
+}
+/**
+ * One text part as the markdown a HISTORY turn carries (tool calls are drawn
+ * as tool rows by `historyParts`).
  */
 function historyText(part) {
     switch (part.part) {
@@ -921,17 +1014,9 @@ function historyText(part) {
             return part.value;
         case 'reference':
             return `\`${part.path}\``;
-        case 'tool': {
-            // No `<details>` here: a HISTORY turn's markdown is rendered without raw
-            // HTML, so the tags show up as text — observed. A replayed tool is one
-            // line plus its output, fenced.
-            const summary = part.pastTenseMessage ?? part.invocationMessage ?? part.toolName;
-            if (!summary)
-                return '';
-            const verb = part.isError ? 'Tool failed:' : 'Tool call:';
-            const result = part.resultText ? `\n\n${fence(part.resultText)}` : '';
-            return `${verb} \`${summary}\`${result}`;
-        }
+        case 'tool':
+            // Drawn as a tool row by `historyParts`.
+            return '';
         case 'answers':
             return `**${part.title}**\n\n${part.message}`;
     }
@@ -1051,7 +1136,7 @@ function registerSessions(context, frontends, participant, granted, handler, con
             if (!connection) {
                 return { history: [], requestHandler: boundHandler };
             }
-            if (controls) {
+            if (controls && !controls.attached(connection)) {
                 controls.setPermission(resource, inputState.groups.find(group => group.id === 'permissions')?.selected?.id);
                 inputState.groups = controls.options(resource);
             }
@@ -1097,16 +1182,12 @@ function registerSessions(context, frontends, participant, granted, handler, con
                     history.push(new turns.ChatRequestTurn(turn.prompt ?? '', undefined, [], participant.id, []));
                     continue;
                 }
-                const markdown = (turn.parts ?? [])
-                    .map(historyText)
-                    .filter(Boolean)
-                    .join('\n\n');
-                history.push(new turns.ChatResponseTurn([new vscode.ChatResponseMarkdownPart(markdown)], {}, participant.id));
+                history.push(new turns.ChatResponseTurn(historyParts(oneRowPerToolCall(turn.parts ?? [])), {}, participant.id));
             }
             const busy = connection.session.descriptor?.turn_state === 'busy';
             return {
                 title: connection.label,
-                options: controls?.currentOptions(resource),
+                options: controls?.attached(connection) ? undefined : controls?.currentOptions(resource),
                 history,
                 requestHandler: boundHandler,
                 activeResponseCallback: busy

package/package.json

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