Files
AgentLab/frontend/src/pages/VerifySettings.tsx
T
ThearchyHelios c8800d75e3 模型接入报错的说法与修复候选收尾(前端):助手栏照实显示存着的模型设定、能重新选「跟随默认」清掉失效的接入;检查器模型一栏说清留空用哪个接入;停用接入的后果写全;问题只认自己那一处的修复
- 助手栏「助手使用的模型」:读 GET /api/copilot/model 的 error,照实写在下拉下面,齿轮上加红点(收着时也看得出来)。存着的
  设定下拉里列不出来(点名了接入,或模型不在可选列表中)时列成一项并选中,不再停在「跟随默认」——以前看着一切正常、
  发出一句话才报错,而且再选「跟随默认」不算改动、清不掉存着的接入,报错又指到改不了它的设置页。这时发出的请求不带
  模型,服务端按存着的整组取,和下拉上显示的一致;
- 检查器模型一栏:节点(没写就是全图默认)点名了接入时,空选项和说明写「使用接入「X」的默认模型」;X 不存在、已停用时
  空选项说状态、不写说明,不再和检查器顶上接入那条问题矛盾(同后端去掉「没有指定模型」那一条);
- 设置页:接入编辑框「启用」旁、卡片上「已停用」的悬停说明写全停用的后果(指定它或它的模型的节点和设置运行时报错),
  不只说下拉里看不到;门控、裁判、核查三格存着的接入名恰好是某个启用接入的模型时,补一句在这一组哪一栏用它,和服务端
  保存时 422 的那句一致;
- 发布前检查:点名的模型接入只认节点、字段都对得上的修复,没有就是这一处没有修复,不再退到同节点、同编号别处的修复
  (同后端 annotate)——以前给不出修复的那一行下面会画着另一处的选项;
- 说法收进 terms.ts(PROVIDER_REF_TEXT、ASSISTANT_MODEL_TEXT),getModel / setModel 的返回补上类型(CopilotModel)。

检查:check-studio 加一节(检查器空选项与说明、助手栏的错误与重新选择、发出的请求不带模型、390 宽不多撑出横向溢出),
check-manage 加一节(停用后果、接入名恰好是模型名)并跟上 422 的新说法,check-publish 的伪造门禁照后端「没有修复时
不指到发布前检查」,加一节给不出修复的那一行不借同节点别处的修复。
2026-10-06 17:51:26 +08:00

363 lines
19 KiB
TypeScript
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
import { useEffect, useRef, useState } from 'react'
import type { ReactNode } from 'react'
import { AlertTriangle } from 'lucide-react'
import { get } from '../api/http'
import { modelOptions, providerOfModel, useCatalog } from '../store/catalog'
import { Field, SectionBar } from '../components/ui'
import { PROVIDER_REF_TEXT, VERIFY_SETTING_TEXT } from '../lib/terms'
import type { Provider, VerifySpend } from '../types'
/*
* 设置页「偏好设置」里「核查」一节:双盲复算、反方审稿、审批质询共用的核查模型、各自的开关和上限、每日金额上限
* (服务端 api/settings.py 的 verify 一组)。
*
* 草稿由 PrefsTab 持有、和其余设置共用一条保存条(这一节只画、只报改动),存的时候整组写 verify:服务端对没给的项
* 回落到默认值,只发改过的那一项会把别的项冲回默认。字段名就是服务端 VERIFY_SETTING_LABEL 的叫法,422 的报错
* 写的也是它,人找得到是哪一项
*/
const T = VERIFY_SETTING_TEXT
const S = VERIFY_SETTING_TEXT.section
type Limit = string | null
/** 草稿:开关是布尔,相对误差是正在填的字符串,上限是字符串或 null(不限)。键就是服务端叫法表里的键 */
export interface VerifyDraft {
provider: string
model: string
'dual_check.enabled': boolean
'dual_check.tolerance': string
'dual_check.max_queries': Limit
'dual_check.timeout_s': Limit
'challenge.enabled': boolean
'challenge.max_claims': Limit
'challenge.max_queries': Limit
'challenge.timeout_s': Limit
'inquiry.enabled': boolean
'inquiry.max_queries': Limit
'inquiry.timeout_s': Limit
daily_max_usd: Limit
}
export type VerifyKey = keyof VerifyDraft
/** 能设成不限的几项 */
type LimitKey = 'dual_check.max_queries' | 'dual_check.timeout_s' | 'challenge.max_claims' | 'challenge.max_queries'
| 'challenge.timeout_s' | 'inquiry.max_queries' | 'inquiry.timeout_s' | 'daily_max_usd'
type Part = 'dual_check' | 'challenge' | 'inquiry'
/** 勾掉「不限」时填回的数:同服务端 VERIFY_DEFAULTS */
const FALLBACK: Record<LimitKey, string> = {
'dual_check.max_queries': '6', 'dual_check.timeout_s': '120', 'challenge.max_claims': '5', 'challenge.max_queries': '4',
'challenge.timeout_s': '90', 'inquiry.max_queries': '6', 'inquiry.timeout_s': '120', daily_max_usd: '2',
}
const COUNTS = new Set<VerifyKey>(['dual_check.max_queries', 'challenge.max_claims', 'challenge.max_queries', 'inquiry.max_queries'])
const TIMEOUTS = new Set<VerifyKey>(['dual_check.timeout_s', 'challenge.timeout_s', 'inquiry.timeout_s'])
const isRecord = (v: unknown): v is Record<string, any> => !!v && typeof v === 'object' && !Array.isArray(v)
/** 一项上限 → 草稿:null 是不限,没有这一项(老服务端、存坏了)当空串 */
const limitText = (v: unknown): Limit => (v === null ? null : v === undefined ? '' : String(v))
/** GET /settings 的 verify 一组(服务端给的是引擎实际生效的样子:存坏了的显示默认,null 是不限)→ 草稿 */
export function verifyDraftOf(group: unknown): VerifyDraft {
const g = isRecord(group) ? group : {}
const part = (p: Part): Record<string, any> => (isRecord(g[p]) ? g[p] : {})
const tol = part('dual_check').tolerance
return {
provider: typeof g.provider === 'string' ? g.provider : '',
model: typeof g.model === 'string' ? g.model : '',
'dual_check.enabled': part('dual_check').enabled !== false,
'dual_check.tolerance': typeof tol === 'number' ? String(tol) : '',
'dual_check.max_queries': limitText(part('dual_check').max_queries),
'dual_check.timeout_s': limitText(part('dual_check').timeout_s),
'challenge.enabled': part('challenge').enabled !== false,
'challenge.max_claims': limitText(part('challenge').max_claims),
'challenge.max_queries': limitText(part('challenge').max_queries),
'challenge.timeout_s': limitText(part('challenge').timeout_s),
'inquiry.enabled': part('inquiry').enabled !== false,
'inquiry.max_queries': limitText(part('inquiry').max_queries),
'inquiry.timeout_s': limitText(part('inquiry').timeout_s),
daily_max_usd: limitText(g.daily_max_usd),
}
}
/** 改过的项(按草稿里的先后) */
export function verifyChanged(cur: VerifyDraft, saved: VerifyDraft): VerifyKey[] {
return (Object.keys(saved) as VerifyKey[]).filter((k) => cur[k] !== saved[k])
}
/** 保存条上这几项的叫法:和字段名、服务端报错同一套 */
export const verifyLabels = (keys: VerifyKey[]): string[] => keys.map((k) => T[k])
/** 各项的问题。同裁判那一组:只校验改过的(存着的值不合规不该挡住别的设置保存),null(不限)总是对的 */
export function verifyErrors(cur: VerifyDraft, saved: VerifyDraft): Partial<Record<VerifyKey, string>> {
const out: Partial<Record<VerifyKey, string>> = {}
for (const k of verifyChanged(cur, saved)) {
const v = cur[k]
if (typeof v !== 'string') continue
const n = Number(v.trim())
if (k === 'dual_check.tolerance') {
if (!(v.trim() !== '' && Number.isFinite(n) && n >= 0)) out[k] = S.invalid.tolerance
} else if (COUNTS.has(k)) {
if (!(/^\d+$/.test(v.trim()) && n >= 1)) out[k] = S.invalid.count
} else if (TIMEOUTS.has(k)) {
if (!(v.trim() !== '' && Number.isFinite(n) && n > 0)) out[k] = S.invalid.seconds
} else if (k === 'daily_max_usd') {
if (!(v.trim() !== '' && Number.isFinite(n) && n > 0)) out[k] = S.invalid.usd
}
}
return out
}
/** 草稿 → 存进去的整组 verify:不限存 null,空着的接入、模型存 null(沿用证据裁判模型) */
export function verifyPayload(cur: VerifyDraft): Record<string, any> {
const limit = (v: Limit) => (v === null ? null : Number(v.trim()))
return {
provider: cur.provider || null,
model: cur.model.trim() || null,
dual_check: {
enabled: cur['dual_check.enabled'],
tolerance: Number(cur['dual_check.tolerance'].trim()),
max_queries: limit(cur['dual_check.max_queries']),
timeout_s: limit(cur['dual_check.timeout_s']),
},
challenge: {
enabled: cur['challenge.enabled'],
max_claims: limit(cur['challenge.max_claims']),
max_queries: limit(cur['challenge.max_queries']),
timeout_s: limit(cur['challenge.timeout_s']),
},
inquiry: {
enabled: cur['inquiry.enabled'],
max_queries: limit(cur['inquiry.max_queries']),
timeout_s: limit(cur['inquiry.timeout_s']),
},
daily_max_usd: limit(cur.daily_max_usd),
}
}
/** 今天花了多少美元:小额按分以下的精度写,不四舍五入成 0(同裁判那一行) */
const formatSpend = (usd: number | undefined): string =>
usd == null || !Number.isFinite(usd) ? '0' : usd >= 1 ? usd.toFixed(2) : String(Number(usd.toFixed(4)))
const fieldId = (k: VerifyKey) => `pref-verify-${k.replace('.', '-')}`
/**
* 「核查」一节。refresh 变了(刚存过 verify 一组)就再取一次今日花费:每日上限变了,那一行的分母跟着变。
* 取不到(老服务端没有这个接口)就不写那一行
*/
export function VerifySection({ cur, errors, onEdit, refresh }: {
cur: VerifyDraft
errors: Partial<Record<VerifyKey, string>>
onEdit: (patch: Partial<VerifyDraft>) => void
refresh: number
}) {
const providers = useCatalog((s) => s.providers)
const [spend, setSpend] = useState<VerifySpend | null>(null)
useEffect(() => {
let alive = true
get<VerifySpend>('/settings/verify/spend').then((s) => { if (alive) setSpend(s) }, () => { if (alive) setSpend(null) })
return () => { alive = false }
}, [refresh])
// 核查模型的接入:两项都留空时服务端沿用证据裁判模型的取值链;只填了模型时这一级整组生效,按模型名找接入
//(verify_model_spec 不跨级拼)——留空那一项不能还叫「跟随证据裁判模型」
const enabledProviders = providers.filter((p) => p.enabled)
const defaultProvider = enabledProviders.find((p) => p.kind !== 'mock') ?? enabledProviders[0]
const provider = cur.provider ? providers.find((p) => p.name === cur.provider) : undefined
const providerMissing = !!cur.provider && providers.length > 0 && !provider
// 点名停用的接入以前照常调用,现在核查时照实报「已停用」、记缺口:和「不存在」一样在这一格下面说。服务端按这一项
// 拒收时(errors.provider,设置页从 422 的 field 落过来)照它的整句。名字恰好是某个启用接入的模型时补一句怎么用它
//(同设置页门控、裁判两组,和服务端保存时那句一致)
const providerTrap = provider?.enabled === false || providerMissing ? providerOfModel(providers, cur.provider) : undefined
const providerNote = providerTrap?.enabled ? `。${PROVIDER_REF_TEXT.modelNote(cur.provider, providerTrap.provider.name, T.model, T.provider)}` : ''
const providerError = errors.provider ?? (providerMissing ? `${S.providerGone(cur.provider)}${providerNote}`
: provider && !provider.enabled
? `${PROVIDER_REF_TEXT.disabled(cur.provider)}:${PROVIDER_REF_TEXT.verifyBroken}${providerNote}` : undefined)
const modelName = cur.model.trim()
const byModel = !cur.provider && !!modelName
const notSet = !cur.provider && !modelName
const owner = byModel ? providerOfModel(providers, modelName) : undefined
const byModelHint = byModel && providers.length > 0
? S.byModel(modelName, owner && { name: owner.provider.name, enabled: owner.enabled }, defaultProvider?.name) : ''
const models = provider ? (provider.models ?? []).map((m) => m.id) : [...new Set(modelOptions(providers).map((o) => o.value))]
const pickProvider = (name: string) => {
// 换了接入,原来填的模型不在新接入的清单里就清掉:拿 A 家的模型名去调 B 家必然失败
const next = name ? providers.find((p) => p.name === name) : undefined
const keep = !name || !cur.model || (next?.models ?? []).some((m) => m.id === cur.model) || next?.default_model === cur.model
onEdit({ provider: name, ...(keep ? {} : { model: '' }) })
}
/** 某项设成不限时,它还受哪些眼下设着的上限约束 */
const note = (k: LimitKey): string => {
// 审批质询不在运行的那一段里执行,只受模型接口的超时约束;双盲复算、反方审稿还受单次运行时限约束
if (TIMEOUTS.has(k)) return S.unlimitedNote(k === 'inquiry.timeout_s' ? 'timeout' : 'runTimeout', [])
if (k === 'challenge.max_claims') return S.unlimitedNote('claims', [S.bound.claims])
if (k === 'daily_max_usd') {
const counts = [...COUNTS].some((c) => cur[c] !== null)
const times = [...TIMEOUTS].some((c) => cur[c] !== null)
return S.unlimitedNote('daily', [counts ? S.bound.queries : '', times ? S.bound.timeouts : ''].filter(Boolean))
}
const part = k.split('.')[0] as Part
return S.unlimitedNote('queries', [cur[`${part}.timeout_s` as LimitKey] !== null ? S.bound.timeout : '',
cur.daily_max_usd !== null ? S.bound.daily : ''].filter(Boolean))
}
const limit = (k: LimitKey, extra?: ReactNode) => (
<LimitInput key={k} k={k} value={cur[k]} fallback={FALLBACK[k]} integer={COUNTS.has(k)} error={errors[k]}
unlimited={note(k)} onChange={(v) => onEdit({ [k]: v } as Partial<VerifyDraft>)} extra={extra} />
)
const toggle = (k: 'dual_check.enabled' | 'challenge.enabled' | 'inquiry.enabled') => (
<label className="mb-2 flex cursor-pointer items-center gap-2 text-xs">
<input type="checkbox" checked={cur[k]} data-verify-toggle={k} onChange={(e) => onEdit({ [k]: e.target.checked })} />
<span>{T[k]}</span>
</label>
)
return (
<section data-verify-settings="">
<SectionBar title={S.title} hint={S.hint} />
<div role="group" aria-labelledby="pref-verify-model-label" aria-describedby="pref-verify-model-hint" data-verify-model="">
<div id="pref-verify-model-label" className="text-xs font-medium">{S.model}</div>
{notSet ? (
// 两项都没填:核查会用证据裁判的模型(没配裁判模型时就是助手的模型)。醒目地说,并给出建议
<div id="pref-verify-model-hint" role="note" data-verify-not-set=""
className="mb-2 mt-1 flex items-start gap-1.5 rounded border-l-2 py-0.5 pl-2 text-2xs leading-relaxed"
style={{ borderColor: 'var(--st-waiting)' }}>
<AlertTriangle size={12} aria-hidden className="mt-0.5 shrink-0" style={{ color: 'var(--st-waiting)' }} />
<span>
<span className="font-medium">{S.notSet}</span>
<span className="block text-dim">{S.notSetAdvice}</span>
</span>
</div>
) : (
<p id="pref-verify-model-hint" className="mb-2 mt-0.5 text-2xs leading-relaxed text-faint">{S.differ}</p>
)}
<div className="grid grid-cols-2 gap-3 max-sm:grid-cols-1">
<Field label={T.provider} htmlFor={fieldId('provider')} error={providerError}
hint={byModelHint ? (
<span data-verify-by-model={owner ? (owner.enabled ? 'found' : 'disabled') : 'default'}
style={owner?.enabled ? undefined : { color: 'var(--st-waiting)' }}>{byModelHint}</span>
) : undefined}>
{(p) => (
<select {...p} className="field" value={cur.provider} onChange={(e) => pickProvider(e.target.value)}>
<option value="">{byModel ? S.providerFromModel : S.providerDefault}</option>
{providerMissing && <option value={cur.provider}>{S.providerGoneOption(cur.provider)}</option>}
<ProviderOptions providers={providers} current={cur.provider} />
</select>
)}
</Field>
<Field label={T.model} htmlFor={fieldId('model')}
hint={provider?.enabled && provider.default_model ? S.modelOf(provider.default_model) : undefined}>
{(p) => (
<>
<input {...p} className="field mono text-xs" value={cur.model} list="pref-verify-models" spellCheck={false}
placeholder={cur.provider ? S.modelDefault : S.modelFollow} onChange={(e) => onEdit({ model: e.target.value })} />
<datalist id="pref-verify-models">{models.map((m) => <option key={m} value={m} />)}</datalist>
</>
)}
</Field>
</div>
</div>
<PartGroup part="dual_check">
{toggle('dual_check.enabled')}
<div className="grid grid-cols-3 gap-3 max-sm:grid-cols-1">
<Field label={T['dual_check.tolerance']} htmlFor={fieldId('dual_check.tolerance')} error={errors['dual_check.tolerance']}
hint={S.toleranceHint}>
{(p) => (
<input {...p} className="field tnum" inputMode="decimal" value={cur['dual_check.tolerance']}
onChange={(e) => onEdit({ 'dual_check.tolerance': e.target.value })} />
)}
</Field>
{limit('dual_check.max_queries')}
{limit('dual_check.timeout_s')}
</div>
</PartGroup>
<PartGroup part="challenge">
{toggle('challenge.enabled')}
<div className="grid grid-cols-3 gap-3 max-sm:grid-cols-1">
{limit('challenge.max_claims')}
{limit('challenge.max_queries')}
{limit('challenge.timeout_s')}
</div>
</PartGroup>
<PartGroup part="inquiry">
{toggle('inquiry.enabled')}
<div className="grid grid-cols-3 gap-3 max-sm:grid-cols-1">
{limit('inquiry.max_queries')}
{limit('inquiry.timeout_s')}
</div>
</PartGroup>
<div className="mt-4 grid grid-cols-3 gap-3 max-sm:grid-cols-1" data-verify-daily="">
{limit('daily_max_usd', spend && (
<div className="mt-1 text-2xs leading-relaxed text-dim" data-verify-spend="">
{spend.calls ? S.spend(formatSpend(spend.usd), spend.calls) : S.spendNone}
{!!spend.unpriced_calls && (
<span className="block" style={{ color: 'var(--st-waiting)' }} data-verify-unpriced="">{S.unpriced(spend.unpriced_calls)}</span>
)}
</div>
))}
</div>
</section>
)
}
/**
* 接入下拉里的各家。停用的照列(带「已停用」),但选不了:选了运行时也调不了,保存时服务端同样会拒收。
* 已经选着的那一个(存着的值后来被停用了)照常显示,下面那一格写明它用不了
*/
export function ProviderOptions({ providers, current }: { providers: Provider[]; current: string }) {
return (
<>
{providers.map((pv) => (
<option key={pv.id} value={pv.name} disabled={!pv.enabled && pv.name !== current}>
{pv.name}{pv.enabled ? '' : S.providerOff}
</option>
))}
</>
)
}
/** 三项各一组:标题是服务端叫法表里那一组的叫法,下面一句说它做什么 */
function PartGroup({ part, children }: { part: Part; children: ReactNode }) {
return (
<div className="mt-4" role="group" aria-labelledby={`pref-verify-${part}-label`} aria-describedby={`pref-verify-${part}-hint`}
data-verify-part={part}>
<div id={`pref-verify-${part}-label`} className="text-xs font-medium">{T[part]}</div>
<p id={`pref-verify-${part}-hint`} className="mb-2 mt-0.5 text-2xs leading-relaxed text-faint">{S.parts[part]}</p>
{children}
</div>
)
}
/**
* 一项上限:数字框加「不限」(照裁判那一组的 LimitField)。勾了不限,框变灰,下面写明不设上限之后还受什么约束——
* 不许悄悄生效;勾掉时填回之前的数(没有就填默认值)
*/
function LimitInput({ k, value, fallback, integer, error, unlimited, onChange, extra }: {
k: LimitKey; value: Limit; fallback: string; integer?: boolean; error?: string; unlimited: string
onChange: (v: Limit) => void; extra?: ReactNode
}) {
const last = useRef(value ?? fallback)
if (value !== null) last.current = value || last.current
const off = value === null
const label = T[k]
return (
<div className="min-w-0" data-verify-limit={k} data-unlimited={off ? '' : undefined}>
<Field label={label} htmlFor={fieldId(k)} error={error}
hint={off ? <span style={{ color: 'var(--st-waiting)' }} data-verify-unlimited="">{unlimited}</span> : undefined}>
{(p) => (
<div className="flex items-center gap-2">
<input {...p} className="field tnum min-w-0 flex-1" inputMode={integer ? 'numeric' : 'decimal'}
value={off ? '' : value} disabled={off} placeholder={off ? S.unlimited : undefined}
onChange={(e) => onChange(e.target.value)} />
<label className="flex shrink-0 cursor-pointer items-center gap-1 text-xs">
<input type="checkbox" checked={off} aria-label={`${label}:${S.unlimited}`} aria-describedby={p['aria-describedby']}
data-verify-unlimited-toggle="" onChange={(e) => onChange(e.target.checked ? null : last.current || fallback)} />
{S.unlimited}
</label>
</div>
)}
</Field>
{extra}
</div>
)
}