dsh-ntr 0.3.3 → 0.3.5

package/src/impl.ts

@@ -867,6 +867,48 @@ export function childEnv(parent: NodeJS.ProcessEnv, extra: Record<string, string
 
 // ---- Model catalog (pure parsing of ACP `configOptions`) ----
 
+/**
+ * ACP categories are free-form UX hints, not identity. Qoder CN tags
+ * `reasoning_effort` as `category: 'model'` (the spec means `thought_level`),
+ * and nothing stops an agent from reusing a category for several options.
+ * Slots are therefore assigned by `configId` first and category second, and a
+ * same-category option NEVER replaces another option's slot: whatever loses
+ * stays reachable through `extras` instead of silently becoming the model list.
+ */
+const EFFORT_OPTION_HINT = /effort|thinking|thought|reason/i
+
+function isModelSelector(configId: string, name: string): boolean {
+  return configId === 'model' || name.trim().toLowerCase() === 'model'
+}
+
+type CatalogSlot = 'model' | 'thought' | 'mode'
+
+interface CatalogSlotCandidate {
+  slot: CatalogSlot
+  rank: number
+  option: AcpCatalogOption
+}
+
+function catalogSlotFor(category: string | undefined, configId: string, name: string): Omit<CatalogSlotCandidate, 'option'> | undefined {
+  const effortish = EFFORT_OPTION_HINT.test(configId) || EFFORT_OPTION_HINT.test(name)
+  if (category === 'model') {
+    // The option explicitly named `model` is the selector even when other
+    // model-scoped options are present.
+    if (isModelSelector(configId, name)) return { slot: 'model', rank: 3 }
+    // A model-scoped effort is mislabelled, not a model: route it to the
+    // thought chip when no real `thought_level` option is published.
+    if (effortish) return { slot: 'thought', rank: 1 }
+    // An unknown model-scoped select: a last-resort selector only.
+    return { slot: 'model', rank: 1 }
+  }
+  if (category === 'thought_level') return { slot: 'thought', rank: 3 }
+  if (category === 'mode') return { slot: 'mode', rank: 2 }
+  // `model_config` is where the spec puts model-dependent knobs (effort,
+  // context size); only the effort-shaped ones have a dedicated control.
+  if (category === 'model_config' && effortish) return { slot: 'thought', rank: 1 }
+  return undefined
+}
+
 /**
  * Extract select options from a raw ACP `configOptions` payload.
  *
@@ -880,24 +922,19 @@ export function childEnv(parent: NodeJS.ProcessEnv, extra: Record<string, string
 export function parseCatalogOptions(configOptions: unknown): AcpAgentCatalog {
   const out: AcpAgentCatalog = {}
   if (!Array.isArray(configOptions)) return out
-  const extras = new Map<string, AcpCatalogOption>()
+  const definitions: AcpCatalogOption[] = []
+  const candidates: CatalogSlotCandidate[] = []
   for (const raw of configOptions) {
     if (typeof raw !== 'object' || raw === null) continue
     const row = raw as Record<string, unknown>
     const category = typeof row.category === 'string' ? row.category : undefined
-    const slot = category === 'model'
-      ? 'model'
-      : category === 'thought_level'
-        ? 'thought'
-        : category === 'mode'
-          ? 'mode'
-          : undefined
     const configIdRaw = row.configId ?? row.id
     if (typeof configIdRaw !== 'string' && typeof configIdRaw !== 'number') continue
     const configId = String(configIdRaw)
     if (configId === '') continue
     const choices: NonNullable<AcpAgentCatalog['model']>['choices'] = []
     collectCatalogChoices(row.options, choices)
+    const name = typeof row.name === 'string' && row.name !== '' ? row.name : configId
     // 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
@@ -906,7 +943,7 @@ export function parseCatalogOptions(configOptions: unknown): AcpAgentCatalog {
       || (typeof row.currentValue === 'boolean' && choices.length === 0)
     const option: AcpCatalogOption = {
       configId,
-      name: typeof row.name === 'string' && row.name !== '' ? row.name : configId,
+      name,
       ...(booleanKind ? { kind: 'boolean' as const } : {}),
       currentValue: booleanKind
         ? row.currentValue === true || row.currentValue === 'true'
@@ -915,21 +952,69 @@ export function parseCatalogOptions(configOptions: unknown): AcpAgentCatalog {
         : typeof row.currentValue === 'string' && row.currentValue !== '' ? row.currentValue : null,
       choices,
     }
+    definitions.push(option)
     // 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 —
-    // except a boolean, whose whole point is that it has no choices.
-    if (choices.length > 0 || booleanKind) extras.set(configId, option)
+    if (booleanKind) continue
+    const slot = catalogSlotFor(category, configId, name)
+    if (slot !== undefined) candidates.push({ ...slot, option })
+  }
+  const winnerIds = new Set<string>()
+  for (const slot of ['model', 'thought', 'mode'] as const) {
+    let winner: CatalogSlotCandidate | undefined
+    for (const candidate of candidates) {
+      if (candidate.slot !== slot) continue
+      if (winner === undefined || candidate.rank > winner.rank) {
+        winner = candidate
+      } else if (candidate.rank === winner.rank && candidate.option.configId === winner.option.configId) {
+        // The same option redefined later in one answer: the last definition
+        // is the current one.
+        winner = candidate
+      }
+    }
+    if (winner === undefined) continue
+    out[slot] = winner.option
+    winnerIds.add(winner.option.configId)
+  }
+  // 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 —
+  // except a boolean, whose whole point is that it has no choices. Anything
+  // that lost a slot race is still a real, settable option: keep it here.
+  const extras = new Map<string, AcpCatalogOption>()
+  for (const option of definitions) {
+    if (winnerIds.has(option.configId)) continue
+    if (option.choices.length > 0 || option.kind === 'boolean') extras.set(option.configId, option)
   }
   if (extras.size > 0) out.extras = [...extras.values()]
   return out
 }
 
+/**
+ * Whether a payload names ONE model selector without relying on category
+ * alone. When an agent publishes several `category: 'model'` options and none
+ * is explicitly the `model` id, the category is not trustworthy enough to
+ * reject the user's pick — callers must fail open instead of reporting
+ * `model_unavailable`.
+ */
+export function hasUnambiguousModelSelector(configOptions: unknown): boolean {
+  if (!Array.isArray(configOptions)) return true
+  let scoped = 0
+  let explicit = false
+  for (const raw of configOptions) {
+    if (typeof raw !== 'object' || raw === null) continue
+    const row = raw as Record<string, unknown>
+    if (row.category !== 'model') continue
+    const configIdRaw = row.configId ?? row.id
+    if (typeof configIdRaw !== 'string' && typeof configIdRaw !== 'number') continue
+    const configId = String(configIdRaw)
+    if (configId === '') continue
+    scoped += 1
+    const name = typeof row.name === 'string' ? row.name : ''
+    if (isModelSelector(configId, name)) explicit = true
+  }
+  return explicit || scoped <= 1
+}
+
 /**
  * Fold one per-session option answer's SHAPE into an agent-level catalog.
  *
@@ -2580,6 +2665,51 @@ export interface SessionLogLike {
   header?: { agentPreset?: unknown }
 }
 
+/**
+ * Structural view of a LIVE host session that can take catalog appends. The
+ * host's `Session.append` validates the payload before committing; an older
+ * host without the `subagent/catalog` event accepts the method but throws,
+ * which the helper below treats as "not supported".
+ */
+export interface SessionCatalogLike extends SessionLogLike {
+  append?: (type: string, data: Record<string, unknown>) => unknown
+}
+
+/**
+ * Record one ACP-side worker in the host's parent-owned subagent catalog as an
+ * EXTERNAL execution. Display-only: external entries have no child session, no
+ * activity/timing and no continuation, and `list_agents` omits them. The
+ * catalog is append-only, so a replayed/resumed dispatch must never add the
+ * same `childId` twice. Returns whether a new fact was appended.
+ */
+export function appendExternalSubagentCatalog(
+  session: SessionCatalogLike | undefined,
+  childId: string,
+  label: string,
+  now = Date.now(),
+): boolean {
+  if (childId === '' || session?.append === undefined) return false
+  const events = session.events
+  if (Array.isArray(events)) {
+    for (let index = events.length - 1; index >= 0; index -= 1) {
+      const event = events[index] as { type?: unknown; data?: { childId?: unknown } } | undefined
+      if (event?.type === 'subagent/catalog' && event.data?.childId === childId) return false
+    }
+  }
+  try {
+    session.append('subagent/catalog', {
+      version: 2,
+      childId,
+      childCreatedAt: now,
+      mode: 'external',
+      label,
+    })
+    return true
+  } catch {
+    return false
+  }
+}
+
 /**
  * The agent preset a session actually runs.
  *

package/src/index.ts

@@ -9,9 +9,9 @@ import type { Context } from '@deepseek-ai/cordis'
 import type {} from '@deepseek-ai/dsh-host-webserver'
 import type { ConnectionRpcHandler, HostConnectionHandle } from '@deepseek-ai/dsh-client-connection'
 import { ACP_PRESET_ID, AcpLlmAdapter, BridgeManager, PLUGIN_VERSION } from './bridge.ts'
-import { EventHub, dispatchRpc, permissionReplayFrames, sessionAgentPreset, sessionAgentPresetFromLog, validateConfig } from './impl.ts'
+import { appendExternalSubagentCatalog, EventHub, dispatchRpc, permissionReplayFrames, sessionAgentPreset, sessionAgentPresetFromLog, validateConfig } from './impl.ts'
 import type { AcpEvent, ApprovalDeadlineKey } from './protocol.ts'
-import type { RosterPresetRow, SessionLogLike } from './impl.ts'
+import type { RosterPresetRow, SessionCatalogLike } from './impl.ts'
 import { UpdateService } from './update.ts'
 import type { UpdateManagerLike } from './update.ts'
 
@@ -39,7 +39,7 @@ interface ChannelRegisteringConnection extends HostConnectionHandle {
 
 /** Structural view of the host session store (`@deepseek-ai/dsh-session`'s `ctx.sessions`). */
 interface SessionsLike {
-  get(sessionId: string): SessionLogLike | undefined
+  get(sessionId: string): SessionCatalogLike | undefined
 }
 
 /**
@@ -260,6 +260,27 @@ export function apply(ctx: Context, config?: unknown): void {
     }
   }
 
+  /**
+   * Optional host integration: record detached ACP workers as EXTERNAL
+   * children in the parent chat session's subagent catalog. Display-only — the
+   * host renders them as read-only "external task" rows with no child
+   * session, activity or continuation — and is skipped silently on hosts
+   * without the catalog event.
+   */
+  const wireSubagentCatalog = (): void => {
+    const sessions = (typeof ctx.get === 'function' ? ctx.get('sessions') : undefined) as SessionsLike | undefined
+    if (sessions === undefined) return
+    manager.setSubagentCatalogReporter((dshSessionId, childId, label) => {
+      let session: SessionCatalogLike | undefined
+      try {
+        session = sessions.get(dshSessionId)
+      } catch {
+        return
+      }
+      appendExternalSubagentCatalog(session, childId, label)
+    })
+  }
+
   wireWorkspace()
   if (typeof ctx.inject === 'function') {
     // Late arrival for the workspace collaborators: a deployment missing one
@@ -271,9 +292,11 @@ export function apply(ctx: Context, config?: unknown): void {
   // The ACP-preset verdict only needs the session store (live) and the
   // persistence store (cold); the sandbox knobs are NOT its dependencies.
   wireAcpMode()
+  wireSubagentCatalog()
   if (typeof ctx.inject === 'function') {
     ctx.inject(['sessions'], () => {
       wireAcpMode()
+      wireSubagentCatalog()
     })
   }
 

package/src/protocol.ts

@@ -346,9 +346,10 @@ export interface AgentView {
 
 /**
  * Why the host released a session's agent process. The browser turns this into
- * one runtime-log line per cause; `idle` stays silent (expected lifecycle).
+ * one runtime-log line per cause; `idle` and `shutdown` stay silent (both are
+ * expected lifecycle transitions, not faults).
  */
-export type AcpReleaseCause = 'idle' | 'workspace' | 'resume-failed' | 'stalled' | 'died'
+export type AcpReleaseCause = 'idle' | 'workspace' | 'resume-failed' | 'stalled' | 'died' | 'shutdown'
 
 export type AcpEvent =
   | { type: 'agent/status'; agentId: string; state: AgentProcessState; error?: string; agent?: AgentView }