@sqdr2/dsh-fusion 0.3.2 → 0.3.3

package/src/client/FusionSettings.tsx

@@ -7,14 +7,19 @@ import { settingsChanged } from './settings-events.js'
 import { tr, useLang } from './i18n.js'
 import { FUSION_API_PATH } from '../identity.js'
 
+/** One saved combo as the page shows it: its id, its label and its pair. */
+export interface SavedPairView { id: string; name: string; pair: PairChoice; authorized: boolean; reason?: string }
 interface SettingsState {
   revision: number
   catalog: SettingsCatalog
-  pair: PairChoice | null
+  pairs: SavedPairView[]
+  maxPairs: number
   authorized: boolean
   managedAuthorization?: boolean
   reason?: string
 }
+/** A row being edited. `id` is absent until the list is saved for the first time. */
+interface DraftCombo { key: string; id?: string; name: string; pair: Partial<PairChoice> }
 const styles = `
 .fusion-page{box-sizing:border-box;width:100%;height:100%;min-width:0;min-height:0;flex:1 1 auto;overflow:auto;display:flex;flex-direction:column;align-items:center;scrollbar-gutter:stable;padding:0 clamp(24px,4vw,48px) 48px;--dsh-scrollbar-width:9px;--dsh-scrollbar-thumb-border:2px}
 .fusion-settings{box-sizing:border-box;width:100%;max-width:680px;margin:0 auto;color:var(--dsw-alias-label-primary);display:flex;flex-direction:column;gap:18px}
@@ -36,8 +41,27 @@ const styles = `
 .fusion-settings details{font-size:13px;line-height:21px}
 .fusion-settings summary{cursor:pointer;font-weight:500}
 .fusion-settings .fusion-limits{display:flex;flex-direction:column;gap:12px;padding-top:14px}
-.fusion-settings input[type=number]{min-width:0;width:100%;box-sizing:border-box;background-color:var(--dsw-alias-bg-layer-1);color:var(--dsw-alias-label-primary);border:1px solid var(--dsw-alias-border-l2);border-radius:7px;padding:8px;font:inherit}
+.fusion-settings :is(input[type=number],input[type=text]){min-width:0;width:100%;box-sizing:border-box;background-color:var(--dsw-alias-bg-layer-1);color:var(--dsw-alias-label-primary);border:1px solid var(--dsw-alias-border-l2);border-radius:7px;padding:8px;font:inherit}
 .fusion-settings .fusion-consent{display:flex;align-items:flex-start;gap:8px;font-size:12px;line-height:18px}
+.fusion-combos{display:flex;flex-direction:column;gap:8px}
+.fusion-settings .fusion-combo{display:flex;align-items:stretch;padding:0;border:1px solid var(--dsw-alias-border-l2);border-radius:10px;background-color:var(--dsw-alias-bg-layer-1);font-size:13px;overflow:hidden;transition:border-color .15s ease,background-color .15s ease}
+.fusion-settings .fusion-combo:hover{background-color:var(--dsw-alias-interactive-bg-hover)}
+.fusion-settings .fusion-combo[data-active=true]{border-color:var(--dsw-alias-brand-primary);background-color:var(--dsw-alias-interactive-bg-hover-accent)}
+.fusion-settings .fusion-combo-main{flex:1 1 auto;display:flex;align-items:center;gap:10px;min-width:0;padding:11px 12px;background:none;border:0;border-radius:0;color:inherit;font:inherit;text-align:left;cursor:pointer}
+.fusion-settings .fusion-combo-main:hover{background:none}
+.fusion-settings .fusion-combo :is(.fusion-combo-main,.fusion-combo-actions):focus-visible{outline:2px solid var(--dsw-alias-brand-primary);outline-offset:-2px}
+.fusion-settings .fusion-combo-check{position:relative;flex:none;width:14px;height:14px;border:1.5px solid var(--dsw-alias-border-l2);border-radius:50%;transition:border-color .15s ease}
+.fusion-settings .fusion-combo:hover .fusion-combo-check{border-color:var(--dsw-alias-label-tertiary)}
+.fusion-settings .fusion-combo[data-active=true] .fusion-combo-check{border-color:var(--dsw-alias-brand-primary)}
+.fusion-settings .fusion-combo[data-active=true] .fusion-combo-check::after{content:'';position:absolute;inset:2.5px;border-radius:50%;background:var(--dsw-alias-brand-primary)}
+.fusion-settings .fusion-combo-text{display:flex;flex-direction:column;gap:2px;min-width:0}
+.fusion-settings .fusion-combo-name{font-weight:600;overflow-wrap:anywhere}
+.fusion-settings .fusion-combo-routes{color:var(--dsw-alias-label-secondary);font-size:12px;overflow-wrap:anywhere}
+.fusion-settings .fusion-combo-actions{flex:none;align-self:stretch;display:flex;align-items:center;padding:0 14px;border:0;border-left:1px solid var(--dsw-alias-border-l1);border-radius:0;background:none;color:var(--dsw-alias-label-secondary);font:inherit;font-size:12px;cursor:pointer;transition:color .15s ease,background-color .15s ease}
+.fusion-settings .fusion-combo-actions:hover:not(:disabled){color:var(--dsw-alias-state-error-primary);background-color:var(--dsw-alias-interactive-bg-hover-danger)}
+.fusion-settings .fusion-combo-actions:disabled{opacity:.4;cursor:default}
+.fusion-settings .fusion-combo-add{align-self:flex-start;padding:8px 16px;border:1px solid var(--dsw-alias-border-l2);border-radius:9px;background:none;color:var(--dsw-alias-label-secondary);font-size:13px}
+.fusion-settings .fusion-combo-add:hover:not(:disabled){background-color:var(--dsw-alias-interactive-bg-hover);color:var(--dsw-alias-label-primary)}
 .fusion-cache{box-sizing:border-box;width:100%;border:1px solid var(--dsw-alias-border-l2);border-radius:8px;background:var(--dsw-alias-bg-module-platform);padding:16px;display:flex;flex-direction:column;gap:12px}
 .fusion-cache h3{margin:0}
 .fusion-cache-summary{cursor:pointer;font-weight:600;font-size:14px;display:flex;align-items:center;justify-content:space-between;list-style:none;user-select:none;padding:2px 0}
@@ -126,76 +150,131 @@ export function ModelChoice({ role, route, catalog, onChange }: {
   </fieldset>
 }
 
+let draftKeys = 0
+const toDraft = (pairs: readonly SavedPairView[]): DraftCombo[] => pairs.map(({ id, name, pair }) => ({ key: id, id, name, pair }))
+
 export function FusionSettings() {
   const lang = useLang()
   const [state, setState] = useState<SettingsState>()
-  const [draft, setDraft] = useState<Partial<PairChoice>>({})
+  const [draft, setDraft] = useState<DraftCombo[]>([])
+  const [active, setActive] = useState(0)
   const [error, setError] = useState<string>()
   const [notice, setNotice] = useState<string>()
   const [saving, setSaving] = useState(false)
-  const chooseModel = (role: 'lead' | 'worker', route: PhysicalRoute) => setDraft(value => ({ ...value, [role]: route,
-    ...(value.cacheKeepalive ? { cacheKeepalive: { ...value.cacheKeepalive, [role]: role === 'lead' ? 'auto' : false } } : {}) }))
+  const current = draft[Math.min(active, draft.length - 1)]
+  const routeName = (route?: PhysicalRoute) => route
+    ? state?.catalog.groups.find(group => group.id === route.provider)?.models.find(model => model.id === route.model)?.name
+      ?? `${route.provider}/${route.model}` : '—'
+  const update = (change: (combo: DraftCombo) => DraftCombo) => setDraft(value => value.map((combo, index) =>
+    combo.key === current?.key ? change(combo) : combo))
+  const chooseModel = (role: 'lead' | 'worker', route: PhysicalRoute) => update(combo => ({ ...combo, pair: { ...combo.pair, [role]: route,
+    ...(combo.pair.cacheKeepalive ? { cacheKeepalive: { ...combo.pair.cacheKeepalive, [role]: role === 'lead' ? 'auto' : false } } : {}) } }))
   useEffect(() => {
     const abort = new AbortController()
     void fetch(`${FUSION_API_PATH}?view=settings`, { credentials: 'same-origin', cache: 'no-store', signal: abort.signal })
       .then(async response => { if (!response.ok) throw new Error(tr(lang, '无法读取 Fusion 设置', 'Cannot read Fusion settings')); return response.json() as Promise<SettingsState> })
-      .then(value => { setState(value); setDraft(value.pair ?? {}) })
+      .then(value => { setState(value); setDraft(toDraft(value.pairs)); setActive(0) })
       .catch(error => { if (!abort.signal.aborted) setError(String(error)) })
     return () => abort.abort()
   }, [])
+  const addCombo = () => {
+    draftKeys += 1
+    setDraft(value => [...value, { key: `new-${draftKeys}`, name: tr(lang, `组合 ${value.length + 1}`, `Combo ${value.length + 1}`), pair: {} }])
+    setActive(draft.length)
+  }
+  const removeCombo = (index: number) => {
+    setDraft(value => value.filter((_, position) => position !== index))
+    setActive(Math.max(0, Math.min(active > index ? active - 1 : active, draft.length - 2)))
+  }
   const save = async () => {
-    if (!state || !draft.lead || !draft.worker) return
+    if (!state) return
+    const invalid = draft.findIndex(combo => !combo.pair.lead || !combo.pair.worker || !combo.name.trim())
+    if (invalid >= 0) { setError(tr(lang, `第 ${invalid + 1} 个组合还不完整：需要名称、Lead 和 Sidekick。`, `Combo ${invalid + 1} is incomplete: it needs a name, a Lead and a Sidekick.`)); return }
     setSaving(true); setError(undefined); setNotice(undefined)
     try {
-      const { outputTokens, ...rest } = draft
-      const limits = Object.fromEntries(Object.entries(outputTokens ?? {}).filter(([, tokens]) => Number.isSafeInteger(tokens) && Number(tokens) > 0))
-      const pair = { ...rest, ...(Object.keys(limits).length ? { outputTokens: limits } : {}) }
+      const pairs = draft.map(({ id, name, pair }) => {
+        const { outputTokens, ...rest } = pair
+        const limits = Object.fromEntries(Object.entries(outputTokens ?? {}).filter(([, tokens]) => Number.isSafeInteger(tokens) && Number(tokens) > 0))
+        return { ...(id ? { id } : {}), name: name.trim(), pair: { ...rest, ...(Object.keys(limits).length ? { outputTokens: limits } : {}) } }
+      })
       const response = await fetch(FUSION_API_PATH, { method: 'POST', credentials: 'same-origin',
-        headers: { 'content-type': 'application/json' }, body: JSON.stringify({ action: 'configure', revision: state.revision, pair }) })
+        headers: { 'content-type': 'application/json' }, body: JSON.stringify({ action: 'configure', revision: state.revision, pairs }) })
       const result = await response.json() as { revision: number; error?: string }
       if (!response.ok) throw new Error(result.error ?? tr(lang, '保存失败，请刷新后重试', 'Save failed; refresh and try again'))
-      const current = await fetch(`${FUSION_API_PATH}?view=settings`, { credentials: 'same-origin', cache: 'no-store' })
-      if (!current.ok) throw new Error(tr(lang, '配置已提交，但暂时无法确认，请刷新', 'Saved, but not confirmed yet; refresh'))
-      const confirmed = await current.json() as SettingsState
-      setState(confirmed); setDraft(confirmed.pair ?? {})
+      const confirmed = await fetch(`${FUSION_API_PATH}?view=settings`, { credentials: 'same-origin', cache: 'no-store' })
+      if (!confirmed.ok) throw new Error(tr(lang, '配置已提交，但暂时无法确认，请刷新', 'Saved, but not confirmed yet; refresh'))
+      const next = await confirmed.json() as SettingsState
+      setState(next); setDraft(toDraft(next.pairs)); setActive(0)
       settingsChanged()
-      setNotice(tr(lang, '组合已保存并启用。可以在模型菜单中选择 Fusion · 自动。', 'Pair saved and enabled. Choose Fusion · auto in the model menu.'))
+      setNotice(tr(lang, '组合已保存。模型菜单中每个组合各占一项，不同会话可以同时使用不同组合。', 'Combos saved. Each one is its own model-menu entry, so different conversations can use different combos at the same time.'))
     } catch (error) { setError(error instanceof Error ? error.message : String(error)) }
     finally { setSaving(false) }
   }
+  const dirty = state ? JSON.stringify(draft.map(({ id, name, pair }) => ({ id, name, pair })))
+    !== JSON.stringify(state.pairs.map(({ id, name, pair }) => ({ id, name, pair }))) : false
+  const blocked = state?.pairs.filter(pair => !pair.authorized) ?? []
   return <div className="fusion-page">
     <style>{styles}</style>
     <div className="fusion-settings">
-      <header data-window-drag><h2>Fusion</h2><p>{tr(lang, '选择 Lead 和 Sidekick。Lead 处理日常请求、安排工作并审查结果；Sidekick 执行委派的任务。', 'Choose a Lead and a Sidekick. The Lead handles requests, plans and reviews; the Sidekick does the delegated work.')}</p>
+      <header data-window-drag><h2>Fusion</h2>
+        <p>{tr(lang, '每个组合是一对 Lead 和 Sidekick，会作为单独的一项出现在模型菜单里。开启多个会话时，可以为每个会话选择不同的组合。', 'Each combo is a Lead and a Sidekick pair, listed as its own entry in the model menu. With several conversations open, each one can use a different combo.')}</p>
+        <p>{tr(lang, 'Lead 处理日常请求、安排工作并审查结果；Sidekick 执行委派的任务。', 'The Lead handles requests, plans and reviews; the Sidekick does the delegated work.')}</p>
         <p><b>{tr(lang, '搭配建议', 'Pairing tip')}</b>: {tr(lang, 'Fusion 省钱靠的是 Sidekick 比 Lead 便宜得多。选一个强的前沿模型当 Lead，再选一个价格低很多（最好 5 倍以上）的模型当 Sidekick；两者价格越接近，越省不了钱。',
           'Fusion saves money because the Sidekick is much cheaper than the Lead. Pick a strong frontier Lead and a Sidekick that costs far less (ideally 5× or more); the closer their prices, the smaller the saving.')}</p></header>
       {error && <p role="alert">{error}</p>}
       {!state && !error && <p role="status">{tr(lang, '正在读取模型…', 'Loading models…')}</p>}
       {state && <>
-        <fieldset className="fusion-card" disabled={saving}>
-          <ModelChoice role="Lead" route={draft.lead} catalog={state.catalog} onChange={route => { if (route) chooseModel('lead', route) }} />
-          <ModelChoice role="Sidekick" route={draft.worker} catalog={state.catalog} onChange={route => { if (route) chooseModel('worker', route) }} />
+        <section className="fusion-card" aria-label={tr(lang, '组合列表', 'Combo list')}>
+          <div className="fusion-combos">
+            {draft.map((combo, index) => {
+              const selected = combo.key === current?.key
+              const label = combo.name.trim() || tr(lang, '未命名组合', 'Untitled combo')
+              // The whole row is the selection target: the button spans the row up to the Delete
+              // button, so the padding and the empty space beside the text select the combo too.
+              return <div className="fusion-combo" key={combo.key} data-active={selected}>
+                <button type="button" className="fusion-combo-main" aria-pressed={selected}
+                  onClick={() => setActive(index)}>
+                  <span className="fusion-combo-check" aria-hidden="true" />
+                  <span className="fusion-combo-text">
+                    <span className="fusion-combo-name">{label}</span>
+                    <span className="fusion-combo-routes">{`${routeName(combo.pair.lead)} → ${routeName(combo.pair.worker)}`}</span>
+                  </span>
+                </button>
+                <button type="button" className="fusion-combo-actions" disabled={saving || draft.length <= 1}
+                  aria-label={tr(lang, `删除组合 ${label}`, `Delete combo ${label}`)}
+                  onClick={event => { event.stopPropagation(); removeCombo(index) }}>{tr(lang, '删除', 'Delete')}</button>
+              </div>
+            })}
+            {!draft.length && <p>{tr(lang, '还没有组合。新增一个，选择 Lead 和 Sidekick 后保存。', 'No combos yet. Add one, choose a Lead and a Sidekick, then save.')}</p>}
+          </div>
+          <button type="button" className="fusion-combo-add" disabled={saving || draft.length >= state.maxPairs} onClick={addCombo}>{tr(lang, '＋ 新增组合', '+ Add combo')}</button>
+          <p>{tr(lang, `最多保存 ${state.maxPairs} 个组合；模型菜单中的名称是「Fusion · 组合名称」。`, `Up to ${state.maxPairs} combos; the model menu shows them as “Fusion · name”.`)}</p>
+        </section>
+        {current && <fieldset className="fusion-card" disabled={saving}>
+          <label>{tr(lang, '名称', 'Name')}<input type="text" maxLength={40} aria-label={tr(lang, '组合名称', 'Combo name')}
+            value={current.name} onChange={event => update(combo => ({ ...combo, name: event.target.value }))} /></label>
+          <ModelChoice role="Lead" route={current.pair.lead} catalog={state.catalog} onChange={route => { if (route) chooseModel('lead', route) }} />
+          <ModelChoice role="Sidekick" route={current.pair.worker} catalog={state.catalog} onChange={route => { if (route) chooseModel('worker', route) }} />
           <details><summary>{tr(lang, '上下文压缩模型 · 可选', 'Compaction model · optional')}</summary>
             <div className="fusion-limits">
               <p>{tr(lang, '默认由当前角色模型压缩。也可以单独选择已连接的模型；请求由所选账号计费。', 'By default each role compacts with its own model. You can pick another connected model; its account is billed.')}</p>
-              <ModelChoice role="compactor" route={draft.compactor?.route} catalog={state.catalog} onChange={route => setDraft(value => {
-                const { compactor, ...rest } = value
-                return route ? { ...rest, compactor: { route, maxOutputTokens: compactor?.maxOutputTokens ?? 8192 } } : rest
+              <ModelChoice role="compactor" route={current.pair.compactor?.route} catalog={state.catalog} onChange={route => update(combo => {
+                const { compactor, ...rest } = combo.pair
+                return { ...combo, pair: route ? { ...rest, compactor: { route, maxOutputTokens: compactor?.maxOutputTokens ?? 8192 } } : rest }
               })} />
-              {draft.compactor && <label>{tr(lang, '输出 Token 上限', 'Output token limit')}<input aria-label={tr(lang, '压缩输出 Token 上限', 'Compaction output token limit')} type="number" min="1" max="128000"
-                value={draft.compactor.maxOutputTokens} onChange={event => { const maxOutputTokens = Number(event.target.value)
-                  setDraft(value => value.compactor ? { ...value, compactor: { ...value.compactor, maxOutputTokens } } : value) }} /></label>}
-              <p>{tr(lang, '已选中的会话仍使用原配置。', 'Conversations already using Fusion keep their setup.')}</p>
+              {current.pair.compactor && <label>{tr(lang, '输出 Token 上限', 'Output token limit')}<input aria-label={tr(lang, '压缩输出 Token 上限', 'Compaction output token limit')} type="number" min="1" max="128000"
+                value={current.pair.compactor.maxOutputTokens} onChange={event => { const maxOutputTokens = Number(event.target.value)
+                  update(combo => combo.pair.compactor ? { ...combo, pair: { ...combo.pair, compactor: { ...combo.pair.compactor, maxOutputTokens } } } : combo) }} /></label>}
             </div>
           </details>
-        </fieldset>
+        </fieldset>}
         <div className="fusion-actions"><p>{tr(lang, '已选中的会话保留原组合；新选择使用新组合。额度耗尽后要换当前任务的 Sidekick，用该会话的 Fusion 恢复面板，而不是只改这里。', 'Conversations already using Fusion keep their pair; new selections use the new one. After a quota stop, switch this conversation\'s Sidekick from its Fusion recovery panel, not only here.')}</p>
-          <button disabled={saving || !draft.lead || !draft.worker || JSON.stringify(draft) === JSON.stringify(state.pair)} onClick={() => { void save() }}>{saving ? tr(lang, '正在保存…', 'Saving…') : tr(lang, '保存组合', 'Save pair')}</button>
+          <button disabled={saving || !dirty || !draft.length} onClick={() => { void save() }}>{saving ? tr(lang, '正在保存…', 'Saving…') : tr(lang, '保存组合', 'Save combos')}</button>
         </div>
         {notice && <p role="status">{notice}</p>}
         <p>{tr(lang, '输出参数跟随原生模型设置，Fusion 不额外限制请求次数或任务轮数。', 'Output settings follow the native model settings; Fusion adds no request or round limits.')}</p>
         <p>{tr(lang, '保存即表示允许 Fusion 使用所选模型的现有账号；费用由这些账号计入，当前未提供可靠的实际账单金额。', 'Saving lets Fusion use the chosen models\' existing accounts; they are billed there, and no reliable billed amount is available here.')}</p>
-        {state.pair && !state.authorized && <p role="status">{tr(lang, '组合需要重新保存后才能使用', 'Save the pair again before use')}{state.reason ? `: ${state.reason}` : ''}</p>}
+        {blocked.map(pair => <p key={pair.id} role="status">{`${pair.name}: ${tr(lang, '尚未就绪，需要重新保存这个组合', 'not ready yet; save this combo again')}${pair.reason ? `: ${pair.reason}` : ''}`}</p>)}
         {state.managedAuthorization && <p>{tr(lang, '运行额度由外部授权配置管理。', 'Run limits are managed by an external authorization file.')}</p>}
       </>}
       <FusionCache refresh={state?.revision ?? 0} />

package/src/client/index.ts

@@ -6,6 +6,7 @@ import type {} from '@deepseek-ai/dsh-client-ui-model-selection/client'
 import { FusionSettings } from './FusionSettings.js'
 import { FusionPanelIcon } from './FusionPanelIcon.js'
 import { FusionHint } from './FusionHint.js'
+import { FusionPermission } from './FusionPermission.js'
 import { FusionTool, fusionControlTools } from './FusionTool.js'
 import { bindLocale } from './i18n.js'
 
@@ -39,12 +40,16 @@ export function apply(ctx: Context): void {
     name: 'sidebar.panellist', id: FUSION_PANEL_ID, order: 40, label: () => 'Fusion',
   }, FusionPanelIcon))
   ctx.inject(['modelDirectories'], scope => {
+    const sessionProps = (sessionId: Parameters<typeof scope.modelDirectories.directoryFor>[0]) => {
+      const directory = scope.modelDirectories.directoryFor(sessionId)
+      return { sessionId, directory: directory.store, load: () => { void directory.load().catch(() => undefined) } }
+    }
     scope.slots.inject('conversation.input.dock', () => scope.slots.register({
-      name: 'conversation.input.dock', id: 'fusion-configuration', order: 20,
-      inject: sessionId => {
-        const directory = scope.modelDirectories.directoryFor(sessionId)
-        return { sessionId, directory: directory.store, load: () => { void directory.load().catch(() => undefined) } }
-      },
+      name: 'conversation.input.dock', id: 'fusion-configuration', order: 20, inject: sessionProps,
     }, FusionHint))
+    // Additive: the native permission control keeps its slot and its selection state.
+    scope.slots.inject('conversation.input.left', () => scope.slots.register({
+      name: 'conversation.input.left', id: 'fusion-permission', order: 10, inject: sessionProps,
+    }, FusionPermission))
   })
 }

package/src/client/status-polling.ts

@@ -72,13 +72,18 @@ function subscribe(sessionId: string, listener: () => void, expanded: () => bool
   }
 }
 
-/** One in-flight read per mounted session; collapsed hints still discover new attention states. */
-export function useFusionStatus(sessionId: string, expandedTask: string | undefined, attentionOnly = false): Snapshot | undefined {
-  const expandedRef = useRef(expandedTask), attentionRef = useRef(attentionOnly)
-  expandedRef.current = expandedTask; attentionRef.current = attentionOnly
+/**
+ * One in-flight read per mounted session; collapsed hints still discover new attention states.
+ * `live` asks for the fast cadence whenever the task is running, for a view whose whole
+ * purpose is the current stage (the role and permission of the model working now).
+ */
+export function useFusionStatus(sessionId: string, expandedTask: string | undefined, attentionOnly = false, live = false): Snapshot | undefined {
+  const expandedRef = useRef(expandedTask), attentionRef = useRef(attentionOnly), liveRef = useRef(live)
+  expandedRef.current = expandedTask; attentionRef.current = attentionOnly; liveRef.current = live
   useEffect(() => { if (expandedTask) entries.get(sessionId)?.visibility() }, [sessionId, expandedTask])
   return useSyncExternalStore(
     useCallback(listener => subscribe(sessionId, listener, () => {
+      if (liveRef.current) return true
       const task = entries.get(sessionId)?.snapshot?.status?.task
       return expandedRef.current !== undefined && task?.id === expandedRef.current && (!attentionRef.current || task.attention)
     }), [sessionId]),

package/src/contracts.ts

@@ -40,6 +40,8 @@ export type RunSelection =
   | { kind: 'profile'; profileId: string; requestedVersion?: string }
 
 export type Role = 'lead' | 'worker'
+/** A Host sandbox mode, spelled as the `sandbox/mode` session event writes it. */
+export type SandboxMode = 'read-only' | 'workspace-write' | 'danger-full-access'
 export type Phase =
   | 'READY'
   | 'PLANNING'

package/src/dsh-fusion.ts

@@ -13,8 +13,10 @@ import type {} from '@deepseek-ai/dsh-host-webserver'
 import type {} from '@deepseek-ai/dsh-commands'
 import type {} from '@deepseek-ai/dsh-agent-default-model'
 import { FusionCatalogAdapter, FUSION_PROVIDER, FUSION_MODEL, installNativeFusionSelection } from './host/native-selection.js'
+import type { FusionModelEntry } from './host/native-selection.js'
 import type { ResolvedProfile } from './profile/resolve.js'
-import { choiceFromProfile, modelProfileFromChoice, validatePairChoice, savedLeadRoute } from './host/settings.js'
+import { choiceFromProfile, modelProfileFromChoice, validatePairChoice, type PairChoice } from './host/settings.js'
+import { MAX_PAIRS, choiceFromStoredProfile, modelOfProfileId, profileIdOf, readPairs, validatePairs, writePairs } from './host/pairs.js'
 import { CachePolicy, cacheView } from './host/cache-policy.js'
 import { CACHE_DEFAULTS_CHECKED } from './host/cache-defaults.js'
 import { loadJsonObject, resolveProfile } from './profile/resolve.js'
@@ -55,22 +57,71 @@ export async function apply(ctx: Context, config: Config = {}): Promise<void> {
   const cachePolicy = new CachePolicy(store)
   backfillHistory(store)
   const budget = new NativeRequestBudget(store, config.authorizationPath)
-  let defaultProfile: ResolvedProfile | undefined
   const physicalCatalog = async () => {
     const catalog = await ctx.sessionController.modelCatalog()
     return { ...catalog, groups: catalog.groups.filter(group => !isFusionProvider(group.id)) }
   }
-  const configuredProfile = async (): Promise<ResolvedProfile> => {
-    defaultProfile = undefined
-    const saved = store.readDocument('settings:profile')
-    if (!saved && (!config.profilePath || !isAbsolute(config.profilePath))) throw new Error(bi('请先在设置的 Fusion 页面选择 Lead 和 Worker', 'Open Settings → Fusion and choose a Lead and a Sidekick first'))
-    const raw = saved?.value as Record<string, unknown> | undefined ?? loadJsonObject(config.profilePath!)
+  /**
+   * The combos to resolve: the saved list, or the one profile file a benchmark
+   * deployment names. A profile file keeps its legacy contract, so only saved
+   * combos are rebuilt from a choice.
+   */
+  const comboPlan = (): { revision: number; items: readonly { id: string; name: string; pair: PairChoice; raw?: Record<string, unknown> }[] } => {
+    const snapshot = readPairs(store)
+    if (snapshot.pairs.length) return { revision: snapshot.revision, items: snapshot.pairs }
+    if (config.profilePath && isAbsolute(config.profilePath)) {
+      const raw = loadJsonObject(config.profilePath)
+      const pair = choiceFromStoredProfile(raw)
+      if (pair) return { revision: snapshot.revision, items: [{ id: FUSION_MODEL, name: '自动', pair, raw }] }
+    }
+    return { revision: snapshot.revision, items: [] }
+  }
+  interface Combos {
+    revision: number
+    items: readonly { id: string; name: string; pair: PairChoice }[]
+    /** Frozen profile of every usable combo, keyed by the model id it advertises. */
+    profiles: Map<string, ResolvedProfile>
+    /** Why one saved combo cannot run yet; the other combos stay usable. */
+    failures: Map<string, string>
+  }
+  let combos: Combos | undefined
+  const resolveCombos = async (): Promise<Combos> => {
+    const plan = comboPlan()
     const catalog = await physicalCatalog()
-    const pair = validatePairChoice(raw, catalog)
-    const next = saved ? modelProfileFromChoice(pair) : raw
-    defaultProfile = resolveProfile(next, next.interactionMode === 'model-like' ? loadModelPromptBundle() : loadPromptBundle(), { authorizedRoutes: catalog.groups.flatMap(group =>
-      group.models.map(model => ({ provider: group.id, model: model.id }))) })
-    return defaultProfile
+    const authorizedRoutes = catalog.groups.flatMap(group => group.models.map(model => ({ provider: group.id, model: model.id })))
+    const profiles = new Map<string, ResolvedProfile>(), failures = new Map<string, string>()
+    for (const item of plan.items) {
+      try {
+        const pair = validatePairChoice(item.pair, catalog)
+        const next = item.raw ?? modelProfileFromChoice(pair, profileIdOf(item.id))
+        profiles.set(item.id, resolveProfile(next, next.interactionMode === 'model-like' ? loadModelPromptBundle() : loadPromptBundle(), { authorizedRoutes }))
+      } catch (error) {
+        // One retired model must not take every other combo down with it.
+        failures.set(item.id, error instanceof Error ? error.message : String(error))
+      }
+    }
+    combos = { revision: plan.revision, items: plan.items.map(({ id, name, pair }) => ({ id, name, pair })), profiles, failures }
+    return combos
+  }
+  const knownCombos = async (): Promise<Combos> => combos ?? await resolveCombos()
+  // A combo list saved from another process (or before the model catalog was
+  // ready at startup) is picked up on first use instead of failing the session.
+  let reloading = false
+  const profileOf = (model: string): ResolvedProfile | undefined => {
+    const found = combos?.profiles.get(model)
+    if (!found && !reloading) {
+      reloading = true
+      void resolveCombos().catch(() => undefined).finally(() => { reloading = false })
+    }
+    return found
+  }
+  /** The profile a plain (unselected) request falls back to: the first usable combo. */
+  const primaryProfile = async (): Promise<ResolvedProfile> => {
+    const state = await knownCombos()
+    const profile = state.profiles.values().next().value
+    if (profile) return profile
+    const [first] = state.failures.values()
+    throw new Error(first ?? bi('请先在设置的 Fusion 页面选择 Lead 和 Worker', 'Open Settings → Fusion and choose a Lead and a Sidekick first'))
   }
   const needsBudget = (profile: ResolvedProfile['profile']) => Boolean(config.authorizationPath) || profile.interactionMode !== 'model-like'
   let runtime: FusionCoordinator | undefined
@@ -82,7 +133,7 @@ export async function apply(ctx: Context, config: Config = {}): Promise<void> {
     if (runtime) return Promise.resolve(runtime)
     if (creating) return creating
     creating = (async () => {
-      const profile = frozen ?? await configuredProfile()
+      const profile = frozen ?? await primaryProfile()
       runtime = new FusionCoordinator(ctx, store, { profile, workerTools: config.workerTools ?? defaultWorkerTools,
         resumeAuthorization: binding => needsBudget(binding.profile) ? budget.check(effectiveRoutes(binding)).authorizationId : 'native-account',
         authorizeRequest: (_agent, binding) => {
@@ -107,28 +158,39 @@ export async function apply(ctx: Context, config: Config = {}): Promise<void> {
     })().finally(() => { creating = undefined })
     return creating
   }
-  // The catalog entry admits what the configured Lead admits: the Lead is the
-  // only role that reads user content, while the Worker receives text work orders.
-  const leadInputModalities = async (): Promise<readonly ModelModality[] | undefined> => {
-    try {
-      const saved = store.readDocument('settings:profile')?.value
-      const lead = savedLeadRoute(saved)
-        ?? (config.profilePath && isAbsolute(config.profilePath) ? savedLeadRoute(loadJsonObject(config.profilePath)) : undefined)
-      if (!lead) return undefined
-      return (await ctx.llm.resolveModelInfo(lead.provider, lead.model)).inputModalities
-    } catch {
-      // An unresolvable Lead route (unregistered provider, retired model, broken
-      // profile file) cannot verify image support; the catalog entry stays text-only.
-      return undefined
+  // Each combo's entry admits what its own Lead admits: the Lead is the only
+  // role that reads user content, while the Worker receives text work orders.
+  // This resolves through the other providers' own model info, never through
+  // this adapter, so listing Fusion cannot recurse into itself.
+  const fusionModels = async (): Promise<readonly FusionModelEntry[]> => {
+    let items: readonly { id: string; name: string; pair: PairChoice }[]
+    try { items = readPairs(store).pairs } catch { return [] }
+    if (!items.length && config.profilePath && isAbsolute(config.profilePath)) {
+      const pair = choiceFromStoredProfile(loadJsonObject(config.profilePath))
+      items = pair ? [{ id: FUSION_MODEL, name: '自动', pair }] : []
     }
+    return Promise.all(items.map(async item => {
+      let modalities: readonly ModelModality[] = []
+      try {
+        // An unresolvable Lead route (unregistered provider, retired model, broken
+        // profile file) cannot verify image support; the entry stays text-only.
+        modalities = (await ctx.llm.resolveModelInfo(item.pair.lead.provider, item.pair.lead.model)).inputModalities ?? []
+      } catch { modalities = [] }
+      return { id: item.id, name: `Fusion · ${item.name}`, inputModalities: modalities }
+    }))
   }
-  ctx.effect(() => ctx.llm.registerAdapter([FUSION_PROVIDER], new FusionCatalogAdapter(leadInputModalities)))
+  ctx.effect(() => ctx.llm.registerAdapter([FUSION_PROVIDER], new FusionCatalogAdapter(fusionModels)))
   ctx.effect(() => installNativeFusionSelection(ctx, {
-    coordinator: () => runtime, profile: () => defaultProfile,
+    coordinator: () => runtime,
+    profile: profileOf,
+    // A combo that cannot run yet says why, instead of the generic "configure first".
+    reason: model => combos?.failures.get(model)
+      ?? (combos?.items.length ? bi('该组合已被删除或无法使用，请在模型菜单中选择其他组合。', 'That combo was removed or cannot run; pick another one in the model menu.') : undefined),
     selection: agent => {
       const selection = agent.session.snapshotEvents().findLast(event => event.type === 'model/selection')
       if (selection?.type === 'model/selection') return selection.data
-      if (bindings.read(agent.id)?.binding.selected) return { provider: FUSION_PROVIDER, model: FUSION_MODEL }
+      const bound = bindings.read(agent.id)?.binding
+      if (bound?.selected) return { provider: FUSION_PROVIDER, model: modelOfProfileId(bound.profile.id) ?? FUSION_MODEL }
       const header = agent.session.requestHeader()
       return header ? { provider: header.config.provider, model: header.config.model } : ctx.agentDefaultModel.currentSelection()
     },
@@ -162,27 +224,35 @@ export async function apply(ctx: Context, config: Config = {}): Promise<void> {
         }
         if (url.searchParams.get('view') === 'catalog') return json(res, 200, await ctx.sessionController.modelCatalog())
         if (url.searchParams.get('view') === 'cache') {
-          let profile: ResolvedProfile | undefined
-          try { profile = await configuredProfile() } catch { profile = undefined }
-          return json(res, 200, { checked: CACHE_DEFAULTS_CHECKED, models: cacheView(cachePolicy,
-            profile ? { lead: profile.profile.lead, worker: profile.profile.worker } : undefined, profile?.profile.cacheKeepalive) })
+          let pairs: { lead: { provider: string; model: string }; worker: { provider: string; model: string }; cacheKeepalive?: PairChoice['cacheKeepalive'] }[] = []
+          try { pairs = [...(await knownCombos()).profiles.values()].map(profile => ({ lead: profile.profile.lead,
+            worker: profile.profile.worker, cacheKeepalive: profile.profile.cacheKeepalive })) } catch { pairs = [] }
+          return json(res, 200, { checked: CACHE_DEFAULTS_CHECKED, models: cacheView(cachePolicy, pairs) })
         }
         if (url.searchParams.get('view') === 'settings') {
-          const saved = store.readDocument('settings:profile')
-          let profile: ResolvedProfile | undefined, reason: string | undefined, authorized = false
-          try {
-            profile = await configuredProfile()
-            if (needsBudget(profile.profile)) budget.check(profileRoutes(profile.profile)); authorized = true
-          } catch (error) { reason = error instanceof Error ? error.message : String(error) }
-          return json(res, 200, { revision: saved?.revision ?? 0, catalog: await physicalCatalog(),
-            pair: profile ? choiceFromProfile(profile.profile) : null,
-            authorized, reason, managedAuthorization: Boolean(config.authorizationPath), policy: profile?.profile.interactionMode ?? 'legacy', actualBilledUsd: null, apiEquivalentUsd: null })
+          // Resolved fresh: the revision a save sends must match the one shown.
+          const state = await resolveCombos()
+          const pairs = state.items.map(item => {
+            const profile = state.profiles.get(item.id)
+            if (!profile) return { id: item.id, name: item.name, pair: item.pair, authorized: false, reason: state.failures.get(item.id) }
+            let authorized = false, reason: string | undefined
+            try { if (needsBudget(profile.profile)) budget.check(profileRoutes(profile.profile)); authorized = true }
+            catch (error) { reason = error instanceof Error ? error.message : String(error) }
+            return { id: item.id, name: item.name, pair: choiceFromProfile(profile.profile), authorized, ...(reason ? { reason } : {}) }
+          })
+          const blocked = pairs.find(pair => !pair.authorized)
+          return json(res, 200, { revision: state.revision, catalog: await physicalCatalog(), pairs, maxPairs: MAX_PAIRS,
+            // The first combo is what the single-pair page and older tabs read.
+            pair: pairs[0]?.pair ?? null, authorized: pairs.length > 0 && !blocked,
+            ...(blocked?.reason ? { reason: blocked.reason } : {}),
+            managedAuthorization: Boolean(config.authorizationPath),
+            policy: state.profiles.values().next().value?.profile.interactionMode ?? 'model-like', actualBilledUsd: null, apiEquivalentUsd: null })
         }
         const sessionId = url.searchParams.get('sessionId') ?? ''
         const binding = sessionId && bindings.read(sessionId)?.binding
         let available = false, reason: string | undefined
         try {
-          const profile = binding && binding.selected ? { profile: binding.profile, prompts: binding.prompts } : await configuredProfile()
+          const profile = binding && binding.selected ? { profile: binding.profile, prompts: binding.prompts } : await primaryProfile()
           const controller = await getRuntime(profile)
           controller.transport.assertAvailable()
           if (needsBudget(profile.profile)) budget.check(profileRoutes(profile.profile))
@@ -252,19 +322,25 @@ export async function apply(ctx: Context, config: Config = {}): Promise<void> {
       }
       if (body.action === 'configure') {
         if (!Number.isSafeInteger(body.revision) || Number(body.revision) < 0) throw new Error(bi('配置版本无效，请刷新后重试', 'Invalid settings revision; refresh and retry'))
-        const pair = validatePairChoice(body.pair, await physicalCatalog())
-        const revision = store.writeDocument('settings:profile', Number(body.revision), modelProfileFromChoice(pair))
-        const profile = await configuredProfile()
-        await getRuntime(profile)
+        const catalog = await physicalCatalog(), current = readPairs(store)
+        // A tab from before combos existed sends one pair; keep the other combos
+        // and let it edit only the first one it can see.
+        const proposed = Array.isArray(body.pairs) ? body.pairs
+          : [{ ...(current.pairs[0] ?? { id: FUSION_MODEL, name: '自动' }), pair: body.pair }, ...current.pairs.slice(1)]
+        const pairs = validatePairs(proposed, catalog, current.pairs)
+        const revision = writePairs(store, Number(body.revision), pairs)
+        const state = await resolveCombos()
+        const profile = state.profiles.values().next().value
+        if (profile) await getRuntime(profile)
         return json(res, 200, { ok: true, revision })
       }
       if (body.action === 'authorize') {
         if (config.authorizationPath) throw new Error(bi('运行额度由外部授权文件管理，不能在此覆盖', 'Run limits are managed by an external authorization file and cannot be overridden here'))
-        const saved = store.readDocument('settings:profile')
-        if (!saved || saved.revision !== body.revision) throw new Error(bi('模型组合已变化，请刷新后再启用额度', 'The pair changed; refresh before enabling limits'))
-        const profile = await configuredProfile()
-        if (store.readDocument('settings:profile')?.revision !== body.revision) throw new Error(bi('模型组合已变化，请刷新后再启用额度', 'The pair changed; refresh before enabling limits'))
-        const auth = authorizeConfiguredPair(store, profileRoutes(profile.profile), body.limits)
+        if (readPairs(store).revision !== body.revision) throw new Error(bi('组合列表已变化，请刷新后再启用额度', 'The combo list changed; refresh before enabling limits'))
+        // One authorization must cover every combo the menu can offer.
+        const state = await resolveCombos()
+        if (readPairs(store).revision !== body.revision) throw new Error(bi('组合列表已变化，请刷新后再启用额度', 'The combo list changed; refresh before enabling limits'))
+        const auth = authorizeConfiguredPair(store, [...state.profiles.values()].flatMap(profile => profileRoutes(profile.profile)), body.limits)
         return json(res, 200, { ok: true, expiresAt: auth.expiresAt })
       }
       throw new Error(bi('请使用原模型菜单选择 Fusion 或切换普通模型', 'Use the model menu to select Fusion or another model'))
@@ -280,7 +356,7 @@ export async function apply(ctx: Context, config: Config = {}): Promise<void> {
       const [action = 'status', ...note] = invocation.rawInput.trim().split(/\s+/)
       try {
         const binding = bindings.read(invocation.agent.id)?.binding
-        if (!binding?.selected) return { kind: 'success', text: bi('当前会话未启用 Fusion。请在模型选择器中选择 Fusion · 自动。', 'Fusion is not selected in this conversation. Choose Fusion · auto in the model menu.') }
+        if (!binding?.selected) return { kind: 'success', text: bi('当前会话未启用 Fusion。请在模型选择器中选择一个 Fusion 组合。', 'Fusion is not selected in this conversation. Choose a Fusion combo in the model menu.') }
         if (action === 'status' || action === '') {
           const controller = await getRuntime({ profile: binding.profile, prompts: binding.prompts })
           const state = store.load(binding.taskId)!
@@ -312,7 +388,7 @@ export async function apply(ctx: Context, config: Config = {}): Promise<void> {
     } }))
   ctx.effect(() => async () => { if (creating) await creating.catch(() => undefined); if (runtime) await runtime.close(); store.close() })
   // Warm only configuration/scopes; initialization performs no inference.
-  try { await getRuntime(await configuredProfile()) }
+  try { await getRuntime(await primaryProfile()) }
   catch {
     const selected = bindings.selected()[0]
     if (selected) await getRuntime({ profile: selected.profile, prompts: selected.prompts })

package/src/host/cache-policy.ts

@@ -148,12 +148,24 @@ export class CachePolicy {
 }
 
 type Route = { provider: string; model: string }
-/** One row of the settings page: what applies, why, what the defaults say, and what was observed. */
-export function cacheView(policy: CachePolicy, pair?: { lead: Route; worker: Route }, pairChoice?: { lead?: boolean | 'auto'; worker?: boolean | 'auto' }) {
-  const same = (a: Route | undefined, provider: string, model: string) => a?.provider === provider && a.model === model
-  return policy.routes(pair ? [pair.lead, pair.worker] : []).map(({ provider, model }) => {
-    const role: Role | undefined = same(pair?.lead, provider, model) ? 'lead' : same(pair?.worker, provider, model) ? 'worker' : undefined
-    const effective = policy.resolve(provider, model, role ?? 'lead', role ? pairChoice?.[role] : undefined)
+/** A saved combo's routes, plus its optional per-role keepalive choice. */
+export interface CachePairRoutes {
+  readonly lead: Route
+  readonly worker: Route
+  readonly cacheKeepalive?: { lead?: boolean | 'auto'; worker?: boolean | 'auto' }
+}
+/**
+ * One row of the settings page: what applies, why, what the defaults say, and
+ * what was observed. Every saved combo contributes its routes, so a second
+ * combo's models are listed and labelled even before a session uses them.
+ */
+export function cacheView(policy: CachePolicy, pair?: CachePairRoutes | readonly CachePairRoutes[], pairChoice?: { lead?: boolean | 'auto'; worker?: boolean | 'auto' }) {
+  const pairs: readonly CachePairRoutes[] = Array.isArray(pair) ? pair : pair ? [pair as CachePairRoutes] : []
+  const same = (role: 'lead' | 'worker', provider: string, model: string) => pairs.some(item => item[role].provider === provider && item[role].model === model)
+  const choiceOf = (role: 'lead' | 'worker') => pairs.find(item => item.cacheKeepalive)?.['cacheKeepalive']?.[role] ?? pairChoice?.[role]
+  return policy.routes(pairs.flatMap(item => [item.lead, item.worker])).map(({ provider, model }) => {
+    const role: Role | undefined = same('lead', provider, model) ? 'lead' : same('worker', provider, model) ? 'worker' : undefined
+    const effective = policy.resolve(provider, model, role ?? 'lead', role ? choiceOf(role) : undefined)
     const stats = policy.stats(provider, model), { family, route } = effective.defaults
     return { provider, model, role,
       mode: effective.mode, intervalSeconds: effective.intervalSeconds, modeSource: effective.modeSource, intervalSource: effective.intervalSource,