@volter/supercode-frontend-vscode 0.1.20 → 0.1.22

package/NOTICE.md

@@ -1,10 +1,6 @@
 # Third-party notice
 
-This optional frontend needs **no runtime npm installation**. Its form-schema validator
-bundles Ajv 8.17.1, ajv-formats 3.0.1 and their dependencies; their license texts ship in
-`dist/request-schema.LICENSE.txt`. esbuild bundles that one module during the build.
-The validator does not fetch external schema references or change answer values.
-It builds against `@types/vscode`
+This optional frontend needs **no runtime npm installation**. It builds against `@types/vscode`
 (Copyright (c) Microsoft Corporation, MIT) as an exact devDependency for types only; `vscode` itself
 is supplied by the editor at runtime and is never bundled or redistributed here.
 

package/README.md

@@ -34,65 +34,6 @@ Changed setup resources refresh
 Code-OSS's cached status history after an install. Hosts without these optional
 fields keep the existing runtime-attachment behavior.
 
-`starterPrompts?: {label: string; prompt: string}[]` is project data supplied by
-the host. An eligible new conversation exposes at most three short command links
-in the default participant's native welcome content, outside the transcript.
-The host's `fillInputCommand` receives the exact native session resource and full
-prompt and must return `{sessionResource, input}` after filling that existing
-widget, without submitting. A missing or mismatched receipt is an error.
-The untargeted partial-query command is not used. Links never send or write a turn.
-Presentation and clicks use the same `starterEligibility` calculation; runtime
-and host state changes update the welcome message, and a user turn clears it.
-Native Chat also hides its welcome surface immediately when a request is added.
-Eligibility requires a successful attachment, an idle runtime, no pending request,
-no saved/canonical non-system messages or truncated saved history, and no observed
-user turn. Accepted-input events (`user_message`, `turn_started`) and busy snapshots
-record turn evidence that survives re-attachment and replay eviction. Setup/status
-events can advance cursors without disqualifying a new conversation; system-only
-history also stays eligible. The checks run again after
-project data loads and before filling; a failed attachment never offers starters.
-`supercode.frontend.status(true)` includes each connection's `starterEligibility`:
-attachment state, turn state, pending count, saved-history presence/truncation/count
-and roles, canonical count/roles, sticky turn evidence, both cursors, replay count
-and kinds, active host ID, host busy state, connection identity check, and rejection
-reasons. `lastStarterAttempt` preserves the exact post-attachment guard snapshot
-and native binding from the latest click. These contain no message bodies or tokens.
-A rejected click names its failed conditions instead of a generic new/idle error.
-The pinned Chat session API exposes immutable history, without withdrawal or
-live enablement of a rendered command part. Starters therefore never enter history.
-`defaultChatParticipant.additionalWelcomeMessage` supplies trusted Markdown with
-only `supercode.frontend.fillStarter` allowed; labels are escaped and command
-arguments are encoded. Hosts without that proposal get no starter offer rather
-than permanent transcript buttons. Existing setup actions keep their native status
-presentation. No new workbench API or editor-side contribution is required.
-The pinned Code-OSS `f16dc165` has no `suggestedPrompts` field in either
-`vscode.proposed.defaultChatParticipant.d.ts` or the internal
-`IChatViewWelcomeContent`. `ChatViewWelcomePart` renders `additionalMessage` as
-Markdown; its optional `firstLinkToButton` converts only one anchor and the
-participant welcome never enables that option. The editor's native overlay can
-render standalone trusted command links as welcome buttons without a new extension
-API; other hosts keep Markdown links. The two introductory lines live together in
-this extension's `package.json`: `chatSessions.welcomeMessage` and
-`supercodeFrontendWelcome.starterIntroduction`. Hosts own their project prompt data.
-If `starterPromptsPending` is true, the project configuration is still loading.
-Empty-conversation resolution refreshes the host until that declaration arrives
-(cancellable, with a 30-second timeout), so native Chat does not cache an empty
-offer before the project adapter loads.
-
-W32/W37 passed starter filling and W37 passed healthy refresh with draft retention.
-W44 passed a real boost turn and exposed a presentation defect: transcript starter
-buttons remained after the turn even though the guard rejected them. W50 passed
-the native welcome fix at `29d8fac99`: all three pointer fills, one real HUD turn,
-first-turn disappearance, return-to-idle suppression, and no starters when reopening
-the earlier conversation with seven history entries. The shorter introductory copy
-is source-only; it needs a frontend build plus a workbench overlay copy.
-The accompanying native button and New Session repairs require a Code-OSS compile.
-W50 also found that the generic native New Session action
-bypasses this provider's creation command; its owning host must route that action
-through `chatSessions/newSession` rather than opening an unbound untitled resource.
-Signed-out/install transitions and failed-discovery/attachment recovery remain
-unverified live. A published frontend and rebuilt workbench are needed for npx users.
-
 A bundling host can expose a private lifecycle endpoint through
 `SUPERCODE_FRONTEND_HOST_URL` and `SUPERCODE_FRONTEND_HOST_CREDENTIAL_FILE`.
 The endpoint must be loopback HTTP and the credential follows the runtime credential-file

package/dist/chat-setup.d.ts

@@ -1,6 +1,4 @@
-/** Native Chat presentation; the host supplies inventory, terminal actions and project data. */
+/** Native Chat presentation; the host supplies inventory and terminal actions. */
 import * as vscode from 'vscode';
-import type { ChatSetupState, ChatStarterPrompt } from './host-controls.js';
+import type { ChatSetupState } from './host-controls.js';
 export declare function setupParts(setup: ChatSetupState): Array<vscode.ChatResponseMarkdownPart | vscode.ChatResponseCommandButtonPart>;
-/** Welcome content is owned by the empty-state renderer, never transcript history. */
-export declare function starterWelcome(prompts: readonly ChatStarterPrompt[], session: string, resource: string, introduction: string): vscode.MarkdownString;

package/dist/chat-setup.js

@@ -1,4 +1,4 @@
-/** Native Chat presentation; the host supplies inventory, terminal actions and project data. */
+/** Native Chat presentation; the host supplies inventory and terminal actions. */
 import * as vscode from 'vscode';
 export function setupParts(setup) {
     const parts = [
@@ -16,14 +16,3 @@ export function setupParts(setup) {
     parts.push(new vscode.ChatResponseCommandButtonPart({ title: 'Check again', command: 'supercode.frontend.refreshSetup' }));
     return parts;
 }
-/** Welcome content is owned by the empty-state renderer, never transcript history. */
-export function starterWelcome(prompts, session, resource, introduction) {
-    const message = new vscode.MarkdownString().appendText(introduction).appendMarkdown('\n\n');
-    message.isTrusted = { enabledCommands: ['supercode.frontend.fillStarter'] };
-    for (const [index, starter] of prompts.slice(0, 3).entries()) {
-        const args = encodeURIComponent(JSON.stringify([session, index, resource]));
-        message.appendMarkdown('[').appendText(starter.label)
-            .appendMarkdown(`](command:supercode.frontend.fillStarter?${args})\n\n`);
-    }
-    return message;
-}

package/dist/extension.js

@@ -1,9 +1,8 @@
-import { adaptRequestSchema, fieldControl, objectValue, requestValidator } from './request-schema.js';
 import { resolveSessionBinding } from './bindings.js';
 import { withTextContext } from './context.js';
 import { randomUUID } from 'node:crypto';
 import { ChatHostControls, runtimeIdentity, harnessDisplayName, turnPermission } from './host-controls.js';
-import { setupParts, starterWelcome } from './chat-setup.js';
+import { setupParts } from './chat-setup.js';
 import * as vscode from 'vscode';
 import { createFrontendClient } from './client.js';
 import { readCredentialFile } from './credential.js';
@@ -34,44 +33,6 @@ const ENV = Object.freeze({
      */
     unavailable: 'SUPERCODE_FRONTEND_UNAVAILABLE',
 });
-/** Transport progress includes setup events; it is not a user-turn count. */
-function conversationEligibility(connection) {
-    const session = connection.session;
-    const inputs = {
-        attachmentState: session.connection,
-        turnState: session.descriptor?.turn_state ?? null,
-        pendingRequestCount: session.pendingRequests.size,
-        historyTruncated: connection.historyTruncated ?? false,
-        persistedHistoryLoaded: connection.persistedHistory !== undefined,
-        persistedHistoryCount: connection.persistedHistory?.length ?? 0,
-        persistedHistoryRoles: connection.persistedHistory?.map(message => message.role) ?? [],
-        canonicalHistoryCount: session.history.length,
-        canonicalHistoryRoles: session.history.map(message => message.role),
-        hasUserTurn: session.hasUserTurn,
-        historyCursor: session.historyCursor,
-        eventCursor: session.cursor,
-        replayLength: session.replay.length,
-        replayKinds: [...new Set(session.replay.map(event => event.kind))],
-        nativeEventKinds: [...new Set(session.replay.filter(event => event.kind === 'native_event')
-                .map(event => event.payload?.kind).filter(kind => typeof kind === 'string'))],
-    };
-    const reasons = [];
-    if (inputs.attachmentState !== 'connected')
-        reasons.push(`attachmentState=${inputs.attachmentState}`);
-    if (inputs.turnState !== 'idle')
-        reasons.push(`turnState=${inputs.turnState}`);
-    if (inputs.pendingRequestCount)
-        reasons.push(`pendingRequestCount=${inputs.pendingRequestCount}`);
-    if (inputs.historyTruncated)
-        reasons.push('saved history is truncated');
-    if (inputs.persistedHistoryRoles.some(role => role !== 'system'))
-        reasons.push('saved history contains a turn');
-    if (inputs.canonicalHistoryRoles.some(role => role !== 'system'))
-        reasons.push('canonical history contains a turn');
-    if (inputs.hasUserTurn)
-        reasons.push('a user turn has been observed');
-    return { ...inputs, eligible: reasons.length === 0, reasons };
-}
 function normalizePermissions(value, fallback) {
     const raw = Array.isArray(value)
         ? value.map(String)
@@ -364,24 +325,6 @@ export async function activate(context) {
     const boundId = (resource) => resolveSessionBinding(resource, controls?.state.sessions ?? [], resourceBindings);
     let applying = Promise.resolve();
     const frontends = new SupercodeFrontends();
-    const starterEligibility = (connection) => {
-        const conversation = conversationEligibility(connection);
-        const activeSession = controls?.state.activeSession ?? null;
-        const hostBusy = Boolean(controls?.state.busy);
-        const connectionMatches = frontends.get(connection.id) === connection;
-        const reasons = [...conversation.reasons];
-        if (!controls)
-            reasons.push('host controls unavailable');
-        if (activeSession !== connection.id)
-            reasons.push(`activeSession=${activeSession}; expected ${connection.id}`);
-        if (hostBusy)
-            reasons.push('hostBusy=true');
-        if (!connectionMatches)
-            reasons.push('connection was replaced');
-        return { ...conversation, controlsAvailable: Boolean(controls), connectionId: connection.id, activeSession, hostBusy, connectionMatches,
-            eligible: reasons.length === 0, reasons };
-    };
-    const lastStarterAttempts = new Map();
     // 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
@@ -390,28 +333,6 @@ export async function activate(context) {
     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;
-    const welcomeParticipants = new Set();
-    const welcomeValues = new WeakMap();
-    const starterResources = new Map();
-    const updateStarterWelcome = () => {
-        if (!granted.has('defaultChatParticipant'))
-            return;
-        const connection = managed();
-        const prompts = controls?.state.starterPrompts ?? [];
-        // This is the click guard's exact state, including host activity and connection
-        // identity. A later idle state must not revive an offer after a user turn.
-        const message = connection && !focusedAttached && !controls?.state.starterPromptsPending
-            && prompts.length && starterEligibility(connection).eligible
-            ? starterWelcome(prompts, connection.id, starterResources.get(connection.id) ?? sessionResource(connection).toString(), context.extension.packageJSON.supercodeFrontendWelcome.starterIntroduction)
-            : new vscode.MarkdownString('');
-        for (const participant of welcomeParticipants) {
-            if (welcomeValues.get(participant) === message.value)
-                continue;
-            participant.additionalWelcomeMessage = message;
-            welcomeValues.set(participant, message.value);
-        }
-    };
-    context.subscriptions.push(frontends.onDidChange(updateStarterWelcome), controlsChanged.event(updateStarterWelcome));
     let approvalAvailable = false;
     context.subscriptions.push(frontends.onDidChange(() => {
         const active = managed();
@@ -574,36 +495,6 @@ export async function activate(context) {
         setupTerminals.set(key, terminal);
         terminal.show();
     }));
-    context.subscriptions.push(vscode.commands.registerCommand('supercode.frontend.fillStarter', async (session, index, nativeResource) => {
-        if (!controls || !Number.isInteger(index) || index < 0 || index > 2)
-            throw new Error('Invalid starter selection.');
-        const connection = frontends.get(session);
-        if (!connection)
-            throw new Error(`Starter prompt unavailable: connection ${session} is absent.`);
-        const resource = nativeResource ? vscode.Uri.parse(nativeResource)
-            : vscode.Uri.from({ scheme: SESSION_SCHEME, authority: session, path: '/conversation' });
-        if (boundId(resource) !== session)
-            throw new Error('The starter has no matching conversation binding.');
-        await connection.session.attach();
-        const guard = starterEligibility(connection);
-        lastStarterAttempts.set(session, { at: new Date().toISOString(), resource: resource.toString(),
-            boundSession: boundId(resource), guard });
-        while (lastStarterAttempts.size > 50)
-            lastStarterAttempts.delete(lastStarterAttempts.keys().next().value);
-        if (!guard.eligible)
-            throw new Error(`Starter prompt unavailable: ${guard.reasons.join('; ')}.`);
-        const prompt = controls.state.starterPrompts?.[index]?.prompt;
-        if (!prompt)
-            throw new Error('This starter is no longer available.');
-        if (!controls.state.fillInputCommand)
-            throw new Error('This host does not support filling a conversation draft.');
-        // The host addresses the existing native widget, never the default participant or last focus.
-        const receipt = await vscode.commands.executeCommand(controls.state.fillInputCommand, resource.toString(), prompt);
-        if (!receipt || receipt.sessionResource !== resource.toString() || receipt.input !== prompt) {
-            throw new Error('Chat did not confirm the requested draft.');
-        }
-        return receipt;
-    }));
     const connectionFor = async (resource) => {
         if (!controls) {
             const connection = frontends.get(resource.authority);
@@ -706,24 +597,6 @@ export async function activate(context) {
         catalogue: () => controls?.state.sessions ?? [],
         bindings: boundId,
         setup: () => controls?.state.setup,
-        prepareStarters: async (session, resource, token) => {
-            // Project configuration can arrive after the runtime connects. Wait for
-            // its real answer before publishing the conversation's welcome actions.
-            const deadline = Date.now() + 30_000;
-            await controls?.refresh();
-            while (controls?.state.starterPromptsPending) {
-                if (token.isCancellationRequested)
-                    throw new vscode.CancellationError();
-                if (Date.now() >= deadline)
-                    throw new Error('Project configuration is still loading. Reopen Chat once the project is ready.');
-                await new Promise(resolve => setTimeout(resolve, 250));
-                await controls.refresh();
-            }
-            if (token.isCancellationRequested)
-                throw new vscode.CancellationError();
-            starterResources.set(session, resource);
-            controlsChanged.fire();
-        },
     };
     context.subscriptions.push(vscode.commands.registerCommand('supercode.frontend.activateSession', async (resource) => { await connectionFor(vscode.Uri.parse(resource)); }));
     context.subscriptions.push(vscode.commands.registerCommand('supercode.frontend.openSession', async (id) => {
@@ -919,8 +792,6 @@ export async function activate(context) {
             const participant = vscode.chat.createChatParticipant(id, handler);
             participant.iconPath = icon();
             participants.push(participant);
-            welcomeParticipants.add(participant);
-            updateStarterWelcome();
             context.subscriptions.push(participant);
         }
         catch (error) {
@@ -943,8 +814,6 @@ export async function activate(context) {
                     ? vscode.chat.createDynamicChatParticipant(SESSION_SCHEME, { name: current.name.replace(/[^a-zA-Z0-9]/g, ''), fullName: current.name, publisherName: 'Volter', description: 'Ask a question or describe a task' }, handler)
                     : vscode.chat.createChatParticipant(SESSION_SCHEME, handler);
                 participant.iconPath = icon();
-                welcomeParticipants.add(participant);
-                updateStarterWelcome();
                 return participant;
             };
             let sessionParticipant = makeParticipant();
@@ -953,7 +822,6 @@ export async function activate(context) {
                 if (participantKey() === previousIdentity)
                     return;
                 previousIdentity = participantKey();
-                welcomeParticipants.delete(sessionParticipant);
                 sessionParticipant.dispose();
                 sessionParticipant = makeParticipant();
                 for (const p of participants)
@@ -1053,8 +921,7 @@ export async function activate(context) {
         if (inspect === true)
             return {
                 connections: frontends.all.map(c => ({ ...frontends.info(c), permissions: [...c.session.permissions],
-                    pendingRequests: [...c.session.pendingRequests.values()], starterEligibility: starterEligibility(c),
-                    lastStarterAttempt: lastStarterAttempts.get(c.id) ?? null })),
+                    pendingRequests: [...c.session.pendingRequests.values()] })),
                 selection: controls?.state.selection, activeSession: controls?.state.activeSession,
                 busy: Boolean(controls?.state.busy || frontends.all.some(c => c.session.descriptor?.turn_state === 'busy' || c.session.pendingRequests.size)),
                 setupHandoff: { hostReady: controls?.state.setup?.ready ?? null, complete: setupHandoffComplete(),
@@ -1474,12 +1341,6 @@ function registerSessions(context, frontends, participant, granted, handler, con
                 }
                 history.push(new turns.ChatResponseTurn(historyParts(oneRowPerToolCall(turn.parts ?? [])), {}, participant.id));
             }
-            // The public API cannot withdraw a rendered history command part. Keep
-            // starters in the default participant's native welcome content instead:
-            // Chat hides that whole surface as soon as the first request is added.
-            if (attached && history.length === 0 && !controls?.attached(connection) && controls) {
-                await controls.prepareStarters(connection.id, resource.toString(), _token);
-            }
             const busy = connection.session.descriptor?.turn_state === 'busy';
             return {
                 title: connection.label,
@@ -1547,46 +1408,28 @@ async function requestContent(request) {
         const document = await vscode.workspace.openTextDocument({ language: 'json', content: JSON.stringify(schema, null, 2) });
         await vscode.window.showTextDocument(document, { preview: true, preserveFocus: true });
     };
-    const adaptedSchema = adaptRequestSchema(schema, payload?.mode);
-    let validate;
-    const structuredFallback = async (initial) => {
+    const structuredInput = async () => {
         await showSchema();
-        const typed = await vscode.window.showInputBox({ title: 'Runtime request', prompt: 'Enter an answer matching the displayed JSON schema.', value: initial === undefined ? undefined : JSON.stringify(initial), ignoreFocusOut: true, validateInput: value => {
-                try {
-                    const parsed = JSON.parse(value);
-                    return objectValue(parsed) ? validate(parsed) : 'Enter a JSON object';
-                }
-                catch {
-                    return 'Enter valid JSON';
-                }
-            } });
+        const typed = await vscode.window.showInputBox({ title: 'Runtime request', prompt: 'Enter your answer as JSON.', ignoreFocusOut: true,
+            validateInput: value => { try {
+                JSON.parse(value);
+                return undefined;
+            }
+            catch {
+                return 'Enter valid JSON';
+            } } });
         return typed === undefined ? undefined : JSON.parse(typed);
     };
-    try {
-        validate = requestValidator(adaptedSchema);
-    }
-    catch (error) {
-        // Keep the structured-input path available with the original schema in
-        // view. Never accept an answer whose constraints cannot be validated.
-        const message = `Cannot validate this request schema: ${String(error.message)}`;
-        validate = () => message;
-        return structuredFallback();
-    }
-    const form = objectValue(adaptedSchema);
+    const form = objectValue(schema);
     const properties = objectValue(form?.properties);
-    // Cross-field conditions, refs and nested schemas use the complete validated
-    // JSON fallback rather than controls that would erase their semantics.
-    const simpleForm = form?.type === 'object' && properties && Object.keys(form).every(key => ['$schema', 'type', 'title', 'description', 'properties', 'required', 'additionalProperties'].includes(key));
-    if (!simpleForm || !properties)
-        return structuredFallback();
-    const fields = Object.entries(properties).map(([name, spec]) => ({ name, spec: objectValue(spec), control: objectValue(spec) ? fieldControl(objectValue(spec)) : undefined }));
-    if (fields.some(field => !field.spec || !field.control))
-        return structuredFallback();
+    if (!properties)
+        return structuredInput();
     const content = Object.create(null);
-    const required = Array.isArray(form.required) ? form.required : [];
-    for (const { name, spec, control } of fields) {
-        const field = spec;
+    const required = Array.isArray(form?.required) ? form.required : [];
+    for (const [name, spec] of Object.entries(properties)) {
+        const field = objectValue(spec) ?? {};
         const title = typeof field.title === 'string' ? field.title : name;
+        const description = typeof field.description === 'string' ? field.description : undefined;
         if (!required.includes(name)) {
             const choice = await vscode.window.showQuickPick(['Provide a value', 'Omit this field'], { title: `${title} (optional)`, ignoreFocusOut: true });
             if (!choice)
@@ -1594,67 +1437,63 @@ async function requestContent(request) {
             if (choice === 'Omit this field')
                 continue;
         }
-        let validateField;
-        try {
-            validateField = requestValidator(field);
-        }
-        catch {
-            // A field can require the root's dialect or references. The full-form
-            // validator already compiled, so the JSON fallback retains them.
-            return structuredFallback(content);
-        }
-        if (control.kind === 'select') {
-            const select = control;
-            while (true) {
-                const options = select.choices.map(choice => ({ ...choice }));
-                let answer;
-                if (select.multiple) {
-                    const selected = await vscode.window.showQuickPick(options, { title, placeHolder: typeof field.description === 'string' ? field.description : undefined, canPickMany: true, ignoreFocusOut: true });
-                    if (!selected)
-                        return undefined;
-                    answer = selected.map(choice => choice.value);
-                }
-                else {
-                    const selected = await vscode.window.showQuickPick(options, { title, placeHolder: typeof field.description === 'string' ? field.description : undefined, ignoreFocusOut: true });
-                    if (!selected)
-                        return undefined;
-                    answer = selected.value;
-                }
-                const error = validateField(answer);
-                if (error) {
-                    await vscode.window.showWarningMessage(error);
-                    continue;
-                }
-                content[name] = answer;
-                break;
+        const multiple = field.type === 'array';
+        const options = fieldChoices(multiple ? objectValue(field.items) ?? {} : field);
+        if (options.length) {
+            if (multiple) {
+                const selected = await vscode.window.showQuickPick(options, { title, placeHolder: description, canPickMany: true, ignoreFocusOut: true });
+                if (!selected)
+                    return undefined;
+                content[name] = selected.map(choice => choice.value);
+            }
+            else {
+                const selected = await vscode.window.showQuickPick(options, { title, placeHolder: description, ignoreFocusOut: true });
+                if (!selected)
+                    return undefined;
+                content[name] = selected.value;
             }
         }
         else {
-            const text = control;
             const parse = (value) => {
-                if (text.type === 'string')
-                    return value;
-                if (!value.trim() || !Number.isFinite(Number(value)))
-                    throw new Error('Enter a valid number');
-                return Number(value);
+                if (field.type === 'number' || field.type === 'integer') {
+                    if (!value.trim() || !Number.isFinite(Number(value)))
+                        throw new Error('Enter a number');
+                    return Number(value);
+                }
+                if (field.type === 'array' || field.type === 'object')
+                    return JSON.parse(value);
+                return value;
             };
-            const typed = await vscode.window.showInputBox({ title, prompt: typeof field.description === 'string' ? field.description : undefined, ignoreFocusOut: true, validateInput: value => {
-                    try {
-                        return validateField(parse(value));
-                    }
-                    catch (error) {
-                        return error.message;
-                    }
-                } });
+            const typed = await vscode.window.showInputBox({ title, prompt: description, ignoreFocusOut: true,
+                validateInput: value => { try {
+                    parse(value);
+                    return undefined;
+                }
+                catch {
+                    return field.type === 'number' || field.type === 'integer' ? 'Enter a number' : 'Enter valid JSON';
+                } } });
             if (typed === undefined)
                 return undefined;
             content[name] = parse(typed);
         }
     }
-    const error = validate(content);
-    if (error) {
-        await vscode.window.showWarningMessage(error);
-        return structuredFallback(content);
-    }
     return content;
 }
+function objectValue(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value) ? value : undefined;
+}
+function fieldChoices(field) {
+    if (Array.isArray(field.enum))
+        return field.enum.map((value, index) => ({ value,
+            label: Array.isArray(field.enumNames) && typeof field.enumNames[index] === 'string' ? field.enumNames[index] : String(value) }));
+    const variants = Array.isArray(field.oneOf) ? field.oneOf : field.anyOf;
+    if (Array.isArray(variants))
+        return variants.flatMap(value => {
+            const option = objectValue(value);
+            return option && Object.hasOwn(option, 'const') ? [{ value: option.const,
+                    label: typeof option.title === 'string' ? option.title : String(option.const) }] : [];
+        });
+    if (field.type === 'boolean')
+        return [{ label: 'True', value: true }, { label: 'False', value: false }];
+    return [];
+}

package/dist/host-controls.d.ts

@@ -11,10 +11,6 @@ export interface ChatChoice {
     description?: string;
     autoStart?: boolean;
 }
-export interface ChatStarterPrompt {
-    label: string;
-    prompt: string;
-}
 export interface ManagedChatSession {
     id: string;
     selection: ChatSelection;
@@ -40,8 +36,6 @@ export interface HostState {
     historyTruncated?: boolean;
     activeSession: string | null;
     openSessionCommand?: string;
-    /** Fill the composer of an exact native session; returns {sessionResource, input}. */
-    fillInputCommand?: string;
     /** The native renderer supports a leading response with no visible user request. */
     responseOnlyHistory?: boolean;
     sessions: ManagedChatSession[];
@@ -55,9 +49,6 @@ export interface HostState {
     actualModel?: string | null;
     configurable: boolean;
     setup?: ChatSetupState;
-    starterPrompts?: ChatStarterPrompt[];
-    /** The host's project configuration has not finished loading yet. */
-    starterPromptsPending?: boolean;
 }
 export interface HostSelectionResult extends HostState {
     connection: Record<string, string>;

package/dist/session.d.ts

@@ -77,8 +77,6 @@ export declare class VscodeFrontendSession {
     history: ChatMessage[];
     historyCursor: number;
     cursor: number;
-    /** Semantic evidence, retained even when replay is evicted or re-attached. */
-    hasUserTurn: boolean;
     /**
      * Every event this attachment has seen, in order — NOT just the last
      * snapshot's. A re-attach asks `afterSequence: cursor`, so its `replay` is

package/dist/session.js

@@ -44,8 +44,6 @@ export class VscodeFrontendSession {
     history = [];
     historyCursor = 0;
     cursor = 0;
-    /** Semantic evidence, retained even when replay is evicted or re-attached. */
-    hasUserTurn = false;
     /**
      * Every event this attachment has seen, in order — NOT just the last
      * snapshot's. A re-attach asks `afterSequence: cursor`, so its `replay` is
@@ -105,8 +103,6 @@ export class VscodeFrontendSession {
             descriptor: structuredClone(snapshot.descriptor),
             pendingRequests: new Map([...this.pendingRequests].map(([id, request]) => [id, structuredClone(request)])),
             cursor: Math.max(this.cursor, snapshot.history_cursor),
-            hasUserTurn: this.hasUserTurn || snapshot.descriptor.turn_state === 'busy'
-                || snapshot.history.some(message => message.role !== 'system'),
         };
         // Validate and project the whole attachment before any observable field
         // moves or a live listener is registered.
@@ -131,7 +127,6 @@ export class VscodeFrontendSession {
         this.appendTranscript(structuredClone(snapshot.replay));
         this.pendingRequests = staged.pendingRequests;
         this.cursor = staged.cursor;
-        this.hasUserTurn = staged.hasUserTurn;
         this.connection = 'connected';
         this.attachedAtMs ??= Date.now();
         if (!this.#subscribed) {
@@ -259,11 +254,6 @@ export class VscodeFrontendSession {
             throw new EventSequenceGapError(state.cursor + 1, event.sequence);
         }
         state.cursor = event.sequence;
-        // Hosted runtimes publish user_message + turn_started when accepting input.
-        // Native init/status notifications also consume sequence numbers, but are
-        // not user turns. Keep this independent of the bounded replay buffer.
-        if (BUSY_KINDS.has(event.kind))
-            state.hasUserTurn = true;
         const payload = (event.payload ?? {});
         if (event.kind === 'request' && payload.type === 'request') {
             const request = payload.request;