dsh-ntr 0.1.3 → 0.1.4

package/lib/impl.js

@@ -222,8 +222,9 @@ export function validateAgentDef(entry, label = 'agent') {
     const exposedModels = row.exposedModels === undefined
         ? undefined
         : normalizeExposedModels(row.exposedModels, `agent "${id}" exposedModels`, 'bad_config');
-    // Optional boolean; stored only when true (absent and false are the same
-    // "off" state, so the persisted file does not carry noise).
+    // Optional boolean, ON by default. Only the explicit opt-out is stored:
+    // `true` and absent are the same "on" state, so the persisted file does not
+    // carry noise.
     const autoDiscoverModels = row.autoDiscoverModels;
     if (autoDiscoverModels !== undefined && typeof autoDiscoverModels !== 'boolean') {
         throw new AcpError('bad_config', `acp: agent "${id}" autoDiscoverModels must be a boolean`);
@@ -245,7 +246,7 @@ export function validateAgentDef(entry, label = 'agent') {
         cwd: cwd,
         allowedCwdRoots: roots,
         ...(exposedModels !== undefined ? { exposedModels } : {}),
-        ...(autoDiscoverModels === true ? { autoDiscoverModels: true } : {}),
+        ...(autoDiscoverModels === false ? { autoDiscoverModels: false } : {}),
         ...(idleTimeoutMs === undefined ? {} : { idleTimeoutMs: idleTimeoutMs }),
     };
 }
@@ -603,25 +604,113 @@ export function parseCatalogOptions(configOptions) {
             continue;
         const choices = [];
         collectCatalogChoices(row.options, choices);
+        // A boolean toggle has no `options` at all; its current value is a JSON
+        // boolean. It is encoded as 'true' / 'false' so the catalog stays
+        // string-typed for every existing reader, and carries `kind` so the
+        // composer renders a checkbox instead of a select.
+        const booleanKind = row.type === 'boolean'
+            || (typeof row.currentValue === 'boolean' && choices.length === 0);
         const option = {
             configId,
             name: typeof row.name === 'string' && row.name !== '' ? row.name : configId,
-            currentValue: typeof row.currentValue === 'string' && row.currentValue !== '' ? row.currentValue : null,
+            ...(booleanKind ? { kind: 'boolean' } : {}),
+            currentValue: booleanKind
+                ? row.currentValue === true || row.currentValue === 'true'
+                    ? 'true'
+                    : row.currentValue === false || row.currentValue === 'false' ? 'false' : null
+                : typeof row.currentValue === 'string' && row.currentValue !== '' ? row.currentValue : null,
             choices,
         };
-        if (slot !== undefined) {
+        // A toggle is never a model / thought / mode SELECT: those controls pick
+        // among choices. It belongs to the advanced base, where it is a checkbox.
+        if (slot !== undefined && !booleanKind) {
             out[slot] = option;
             continue;
         }
         // Choice-less options have nothing to pick; they would render an empty
-        // section in the advanced menu, so they stay out of the catalog entirely.
-        if (choices.length > 0)
+        // section in the advanced menu, so they stay out of the catalog entirely —
+        // except a boolean, whose whole point is that it has no choices.
+        if (choices.length > 0 || booleanKind)
             extras.set(configId, option);
     }
     if (extras.size > 0)
         out.extras = [...extras.values()];
     return out;
 }
+/**
+ * Fold one per-session option answer's SHAPE into an agent-level catalog.
+ *
+ * `session/set_config_option` answers are often the ONLY place an agent
+ * publishes how its option set changes with the model — opencode offers
+ * `thought_level` (`effort`) just for models with variants and never
+ * re-notifies after a client-driven set — and the composer's thought chip is
+ * driven by the agent-level catalog. What is agent knowledge there is the
+ * SHAPE (which slots exist, which choices they offer); `currentValue` is not:
+ * in a per-session answer it is that session's pick, and promoting it would
+ * turn one conversation's choice into `reasoning.defaultEffort` for every
+ * other one. A merged slot therefore keeps the catalog's known current value
+ * while the observed choices still offer it, and `null` ("the agent's own
+ * default") otherwise. Slots the answer does not mention are left alone — a
+ * different model may still offer them.
+ */
+export function mergeCatalogShape(existing, observed) {
+    const out = {};
+    const merge = (prev, next) => {
+        const kept = prev?.currentValue ?? null;
+        return {
+            configId: next.configId,
+            name: next.name,
+            ...(next.kind === 'boolean' ? { kind: 'boolean' } : {}),
+            // A boolean has no choices to test `kept` against; it keeps the
+            // catalog's known default like any other slot (the answer's value is
+            // still one session's truth, not the agent's).
+            currentValue: kept !== null && (next.choices.length === 0 || next.choices.some(choice => choice.value === kept)) ? kept : null,
+            choices: next.choices,
+        };
+    };
+    for (const slot of ['model', 'thought', 'mode']) {
+        const prev = existing?.[slot];
+        const next = observed[slot];
+        if (next === undefined) {
+            if (prev !== undefined)
+                out[slot] = prev;
+            continue;
+        }
+        out[slot] = merge(prev, next);
+    }
+    // Extras merge by configId: observed entries refresh their shape, entries
+    // only the earlier answer knew survive (another model may still offer them).
+    const extras = new Map();
+    for (const option of existing?.extras ?? [])
+        extras.set(option.configId, option);
+    for (const option of observed.extras ?? [])
+        extras.set(option.configId, merge(extras.get(option.configId), option));
+    if (extras.size > 0)
+        out.extras = [...extras.values()];
+    return out;
+}
+/**
+ * Size ceiling for one `configOptions` answer to be believed. Normal answers
+ * are a few KB (a 500-model catalog is well under this); beyond it the agent is
+ * misbehaving and absorbing/persisting it would turn every notification into
+ * an unbounded write.
+ */
+export const MAX_CONFIG_OPTIONS_BYTES = 1 << 20;
+/**
+ * Whether a `configOptions` answer may overwrite known state.
+ *
+ * An EMPTY (or absent) answer is a non-answer: observed agents return
+ * `configOptions: []` in intermediate states, and treating that as "this agent
+ * now has no options" would wipe a perfectly good catalog and session
+ * snapshot for a state that passes (the rule OmniTerm settles on for the same
+ * observation — empty sets never overwrite the last known state). Oversized
+ * answers are dropped for the same reason: see {@link MAX_CONFIG_OPTIONS_BYTES}.
+ */
+export function usableConfigOptions(configOptions) {
+    if (!Array.isArray(configOptions) || configOptions.length === 0)
+        return false;
+    return JSON.stringify(configOptions).length <= MAX_CONFIG_OPTIONS_BYTES;
+}
 /** Flatten select `options` (plain values or `SessionConfigSelectGroup`s) into choices, deduped by value. */
 function collectCatalogChoices(options, out) {
     if (!Array.isArray(options))
@@ -1353,8 +1442,12 @@ export async function dispatchRpc(manager, endpoint, payload) {
             case 'session/chat-config-set': {
                 const dshSessionId = str(body, 'dshSessionId', 128);
                 const configId = str(body, 'configId', 128);
-                const value = str(body, 'value', 512);
-                await manager.setChatSessionConfig?.(dshSessionId, configId, value, optionalStr(body, 'agentId', 64));
+                const value = body.value;
+                if (typeof value === 'boolean') {
+                    await manager.setChatSessionConfig?.(dshSessionId, configId, value, optionalStr(body, 'agentId', 64));
+                    return ok({ done: true });
+                }
+                await manager.setChatSessionConfig?.(dshSessionId, configId, str(body, 'value', 512), optionalStr(body, 'agentId', 64));
                 return ok({ done: true });
             }
             case 'preset/status':

package/lib/types/bridge.d.ts

@@ -203,7 +203,13 @@ export declare class AgentBridge {
     private readonly transcriptMax;
     /** Called when the connection dies so the manager can settle outstanding prompts. */
     private readonly onConnectionLost;
-    /** Observes `configOptions` from any real session so the manager's model catalog stays warm. */
+    /**
+     * Observes `configOptions` from any real session so the manager's model
+     * catalog stays warm. `shapeOnly` marks a per-session answer (a
+     * `session/set_config_option` response): only the option SHAPE belongs in
+     * the agent-level catalog, never its `currentValue` — see
+     * {@link BridgeManager.absorbCatalogShape}.
+     */
     private readonly onCatalog?;
     /** Observes `availableCommands` from any real session so the agent's slash menu survives its sessions. */
     private readonly onCommands?;
@@ -279,8 +285,14 @@ export declare class AgentBridge {
     constructor(def: AcpAgentDef, hub: EventHub, transcriptMax: number, 
     /** Called when the connection dies so the manager can settle outstanding prompts. */
     onConnectionLost: (bridge: AgentBridge, reason: string) => void, 
-    /** Observes `configOptions` from any real session so the manager's model catalog stays warm. */
-    onCatalog?: ((agentId: string, configOptions: unknown) => void) | undefined, 
+    /**
+     * Observes `configOptions` from any real session so the manager's model
+     * catalog stays warm. `shapeOnly` marks a per-session answer (a
+     * `session/set_config_option` response): only the option SHAPE belongs in
+     * the agent-level catalog, never its `currentValue` — see
+     * {@link BridgeManager.absorbCatalogShape}.
+     */
+    onCatalog?: ((agentId: string, configOptions: unknown, shapeOnly?: boolean) => void) | undefined, 
     /** Observes `availableCommands` from any real session so the agent's slash menu survives its sessions. */
     onCommands?: ((agentId: string, commands: NonNullable<SessionView["availableCommands"]>) => void) | undefined, tuning?: BridgeTuning, 
     /**
@@ -1095,7 +1107,7 @@ export declare class BridgeManager {
      * A live session is updated immediately; a failure there is warned about and
      * the pick still stands, exactly like the model/effort alignment path.
      */
-    setChatSessionConfig(dshSessionId: string, configId: string, value: string, agentId?: string): Promise<void>;
+    setChatSessionConfig(dshSessionId: string, configId: string, value: string | boolean, agentId?: string): Promise<void>;
     /**
      * Apply a conversation's persisted pick to a session that just materialized —
      * created by the first turn, or resumed through `session/load` after a crash.
@@ -1209,6 +1221,18 @@ export declare class BridgeManager {
      * current `parseCatalogOptions` has now seen this agent's real answer.
      */
     private absorbCatalog;
+    /**
+     * Fold a per-session option answer's SHAPE into the agent's catalog.
+     *
+     * The counterpart of {@link absorbCatalog} for `session/set_config_option`
+     * responses: which options exist and which choices they offer is agent
+     * knowledge the seat must show (the composer's thought chip only renders
+     * when the catalog has `thought_level`, and some agents publish it only in
+     * the answer to a model change), while a per-session `currentValue` stays
+     * out of it. No auto-exposure and no staleness discharge either — this is
+     * one session's answer, not the agent-level observation those marks track.
+     */
+    private absorbCatalogShape;
     /**
      * Remember the slash commands an agent declared in a real session.
      *
@@ -1229,7 +1253,8 @@ export declare class BridgeManager {
      * selection would resurrect a model the user deliberately unchecked every
      * time the agent repeats its catalog. The first observation has no baseline
      * (`before === undefined`), so it adds nothing; the user can still add the
-     * whole list with one click in the settings card.
+     * whole list with one click in the settings card. Discovery is ON unless the
+     * agent definition explicitly opts out with `autoDiscoverModels: false`.
      */
     private autoExposeNewModels;
     /** Tell the browser an agent's model-visibility surface changed outside `agent/save`. */
@@ -1382,7 +1407,8 @@ export declare class BridgeManager {
      * Toggle auto-discovery of newly published models. Lightweight like
      * `setExposedModels`: the def is mutated in place (live bridges share the
      * object) and persisted; no process is restarted, and the current selection
-     * is left exactly as it is.
+     * is left exactly as it is. On is the default, so only the opt-out
+     * (`false`) is written to the file.
      */
     setAutoDiscoverModels(agentId: string, autoDiscoverModels: boolean): Promise<void>;
     deleteAgent(agentId: string): Promise<void>;

package/lib/types/client/acp-ui.d.ts

@@ -299,6 +299,12 @@ export interface AcpMenuItem {
     disabled?: boolean;
     /** Leading status dot color (agent process state). */
     dot?: string;
+    /**
+     * Render as a checkbox row (`menuitemcheckbox`) rather than a radio row.
+     * The advanced base uses it for the agent's boolean config options: one row
+     * whose check IS the current value, whose `id` is the value a click sets.
+     */
+    checkbox?: boolean;
 }
 /** One titled block of rows. */
 export interface AcpMenuSection {

package/lib/types/client/session-controls.d.ts

@@ -182,6 +182,8 @@ export declare function describeRoute(agents: readonly AgentView[], bound: ChatS
 export interface AdvancedOption {
     configId: string;
     name: string;
+    /** `'boolean'` for an on/off toggle (`value` is `'true'` / `'false'`, no choices). */
+    kind?: 'boolean';
     /** The conversation's pick, else the value the agent reports as current. */
     value?: string;
     choices: readonly {

package/lib/types/client/store.d.ts

@@ -579,7 +579,7 @@ export declare class AcpStore {
     /** Switch the bound agent's reasoning effort for one chat session. */
     setChatSessionEffort(dshSessionId: string, effort: string | undefined, agentId?: string): Promise<void>;
     /** Set one of the bound agent's EXTRA config options for one chat session. */
-    setChatSessionConfig(dshSessionId: string, configId: string, value: string, agentId?: string): Promise<void>;
+    setChatSessionConfig(dshSessionId: string, configId: string, value: string | boolean, agentId?: string): Promise<void>;
     /**
      * Patch one conversation's optimistic pick. The agent half is required by the
      * record (a model or thought level belongs to an agent). Its owner is the

package/lib/types/impl.d.ts

@@ -145,6 +145,41 @@ export declare function childEnv(parent: NodeJS.ProcessEnv, extra: Record<string
  * anything unusable is skipped silently.
  */
 export declare function parseCatalogOptions(configOptions: unknown): AcpAgentCatalog;
+/**
+ * Fold one per-session option answer's SHAPE into an agent-level catalog.
+ *
+ * `session/set_config_option` answers are often the ONLY place an agent
+ * publishes how its option set changes with the model — opencode offers
+ * `thought_level` (`effort`) just for models with variants and never
+ * re-notifies after a client-driven set — and the composer's thought chip is
+ * driven by the agent-level catalog. What is agent knowledge there is the
+ * SHAPE (which slots exist, which choices they offer); `currentValue` is not:
+ * in a per-session answer it is that session's pick, and promoting it would
+ * turn one conversation's choice into `reasoning.defaultEffort` for every
+ * other one. A merged slot therefore keeps the catalog's known current value
+ * while the observed choices still offer it, and `null` ("the agent's own
+ * default") otherwise. Slots the answer does not mention are left alone — a
+ * different model may still offer them.
+ */
+export declare function mergeCatalogShape(existing: AcpAgentCatalog | undefined, observed: AcpAgentCatalog): AcpAgentCatalog;
+/**
+ * Size ceiling for one `configOptions` answer to be believed. Normal answers
+ * are a few KB (a 500-model catalog is well under this); beyond it the agent is
+ * misbehaving and absorbing/persisting it would turn every notification into
+ * an unbounded write.
+ */
+export declare const MAX_CONFIG_OPTIONS_BYTES: number;
+/**
+ * Whether a `configOptions` answer may overwrite known state.
+ *
+ * An EMPTY (or absent) answer is a non-answer: observed agents return
+ * `configOptions: []` in intermediate states, and treating that as "this agent
+ * now has no options" would wipe a perfectly good catalog and session
+ * snapshot for a state that passes (the rule OmniTerm settles on for the same
+ * observation — empty sets never overwrite the last known state). Oversized
+ * answers are dropped for the same reason: see {@link MAX_CONFIG_OPTIONS_BYTES}.
+ */
+export declare function usableConfigOptions(configOptions: unknown): configOptions is unknown[];
 /**
  * Split an adapter model id into its agent id and optional model choice.
  * `@` is the separator because agent ids are restricted to `[a-z0-9._-]`.
@@ -598,7 +633,7 @@ export interface AcpManager {
     /** Switch the reasoning effort for one chat session (agentId names the default-agent case). */
     setChatSessionEffort?(dshSessionId: string, effort: string | undefined, agentId?: string): Promise<void>;
     /** Set one of the agent's EXTRA config options for one chat session. */
-    setChatSessionConfig?(dshSessionId: string, configId: string, value: string, agentId?: string): Promise<void>;
+    setChatSessionConfig?(dshSessionId: string, configId: string, value: string | boolean, agentId?: string): Promise<void>;
     /**
      * State of the ACP-mode agent preset in the harness's OWN roster. Read-only
      * report for the settings panel: the preset is a declaration this package

package/lib/types/protocol.d.ts

@@ -62,12 +62,13 @@ export interface AcpAgentDef {
      */
     exposedModels?: string[];
     /**
-     * Auto-discovery for {@link exposedModels}: when true, every model the agent
-     * NEWLY publishes (present in an observed catalog but absent from the one
-     * known before it) is appended to `exposedModels` automatically. It never
+     * Auto-discovery for {@link exposedModels}, ON by default: every model the
+     * agent NEWLY publishes (present in an observed catalog but absent from the
+     * one known before it) is appended to `exposedModels` automatically. It never
      * touches models the user already had selected, and the very first catalog
-     * observation is a baseline (nothing is "new" yet). Set from the settings
-     * card's lightweight `agent/set-auto-discover-models` RPC — never by
+     * observation is a baseline (nothing is "new" yet). `false` is the explicit
+     * opt-out and the only value persisted; unset means "on". Flipped from the
+     * settings card's lightweight `agent/set-auto-discover-models` RPC — never by
      * `agent/save`, which restarts the process for connection changes.
      */
     autoDiscoverModels?: boolean;
@@ -566,7 +567,7 @@ export interface ChatEffortSetPayload {
 export interface ChatConfigSetPayload {
     dshSessionId: string;
     configId: string;
-    value: string;
+    value: string | boolean;
     agentId?: string;
 }
 /** Host-detected agent presence and tested defaults. */
@@ -593,7 +594,7 @@ export interface AgentSavePayload {
     allowedCwdRoots?: string[];
     env?: Record<string, string>;
     exposedModels?: string[];
-    /** Keep newer models the agent publishes in the selection (see {@link AcpAgentDef.autoDiscoverModels}). */
+    /** Opt out of auto-discovery with `false`; absent keeps the default (on). See {@link AcpAgentDef.autoDiscoverModels}. */
     autoDiscoverModels?: boolean;
     /** Absent → keep the host default (30 minutes); `0` = never release. */
     idleTimeoutMs?: number;
@@ -636,6 +637,12 @@ export interface AcpCatalogChoice {
 export interface AcpCatalogOption {
     configId: string;
     name: string;
+    /**
+     * `'boolean'` for an on/off toggle: `currentValue` is the string `'true'` /
+     * `'false'` (the catalog stays string-typed so every existing reader keeps
+     * working) and `choices` is empty. Absent means the ordinary select.
+     */
+    kind?: 'boolean';
     /** Currently selected value at parse time (may be absent from `choices`). */
     currentValue: string | null;
     choices: AcpCatalogChoice[];
@@ -713,7 +720,7 @@ export interface AcpConversationChoice {
      * accepts, persisted per conversation so a pick survives a restart and is
      * re-applied when its ACP session is recreated or resumed.
      */
-    extraConfigs?: Record<string, string>;
+    extraConfigs?: Record<string, string | boolean>;
 }
 /** Result of `agent/probe-models`: the freshly probed (or cached) catalog. */
 export interface AgentProbeModelsResult {
@@ -726,6 +733,13 @@ export interface AgentCatalogExtraOption {
     configId: string;
     /** The agent's own option name (falls back to the config id host-side). */
     name: string;
+    /**
+     * `'boolean'` for an on/off toggle (`currentValue` is `'true'` / `'false'`,
+     * `choices` is empty and the composer renders a checkbox row). Absent means
+     * the ordinary select. Kept optional so cached catalogs written before
+     * toggles existed still read.
+     */
+    kind?: 'boolean';
     /** The value the agent reports as current, when it reports one. */
     currentValue?: string;
     choices: Array<{

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-ntr",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "description": "Interactive Agent Client Protocol (ACP) client for the DSH web UI: attach any ACP-capable agent and stream its session.",
   "repository": "https://github.com/GDWhisper/dsh-ntr.git",
   "type": "module",