World's first open-source enterprise world model.
Rust agent-memorybitemporalgraphragknowledge-baseknowledge-graphllmontologypgvectorpostgresqlragrustself-hostedsemantic-searchtemporal-knowledge-graphworld-model
import { useEffect, useState } from "react";
import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
import { useSearch } from "@tanstack/react-router";
import { Plus, X } from "lucide-react";
import { api, type DataSourceView } from "../api";
import { LANG_NAMES, S } from "../i18n";
import { useKb } from "../kb";
import { toast } from "../toast";
import {
Button,
Checkbox,
Chip,
Dialog,
Dropdown,
Field,
IconButton,
Input,
LinkButton,
Pill,
SearchSelect,
Segmented,
SettingsCard,
Table,
TBody,
Td,
Th,
THead,
Tr,
PageHeader,
chipLike,} from "../ui";
import { Members } from "./Members";
import { SsoAdmin } from "./Sso";
/** 两张模型卡的备注只讲一件事,且只讲最新的那件(#698)。
*
* 从前备注是"有测试结果就说测试,否则说保存"——测完再改键,旧结果还贴在卡上;
* 测一次是两套一起测,两个按钮却一起转"Testing…";嵌入卡的报错还是正文字色,
* 聊天卡的报错却是危险色。于是"Saved" 说的是哪次操作、这次测的又是哪张卡,
* 全得靠猜。
*
* 三条规矩,显示层只管最后一条,前两条在调用处用 reset 保证:
* 1. 改任何一格、按任何一次保存,旧结论(测试结果、Saved、报错)全部过期;
* 2. "Testing…" 只亮在按下的那张卡上(`testCard`),因为测的虽然是两套,
* 人按的是这一张;
* 3. 新测到的结果(含测挂了)盖掉旧保存态——刚按了"测试",卡上就该说测试的事。
*
* 传纯数据、回纯结论(含用哪个色调),字串仍在调用处配 i18n;
* 纯函数方便 vitest 直接钉住这张优先级表。 */
export type ModelCardTest = { ok: boolean; message: string } | null;
/** `dirty`:这张卡有改过、还没保存的格子 */
export type ModelCardSave = { error: string | null; saved: boolean; dirty: boolean };
export type ModelCardStatus =
| { kind: "note"; tone: "text-ok" | "text-danger"; text: string }
| { kind: "unsaved" }
| { kind: "saved" }
| { kind: "idle" };
export function modelCardStatus(
test: ModelCardTest,
testError: string | null,
save: ModelCardSave,
): ModelCardStatus {
/* 测试测的永远是**已保存**的那份配置。卡上有没存的修改时,任何测试结果说的都不是
表单里这一份——从前改了密钥直接点测试,看到的是旧密钥的「已连通」,或者格子都填着
却说 Not configured(#698 的第 2、3 条)。保存失败的报错仍然先说 */
if (save.error)
return { kind: "note", tone: "text-danger", text: save.error };
if (save.dirty) return { kind: "unsaved" };
if (test)
return test.ok
? { kind: "note", tone: "text-ok", text: test.message }
: { kind: "note", tone: "text-danger", text: test.message };
if (testError) return { kind: "note", tone: "text-danger", text: testError };
if (save.saved) return { kind: "saved" };
return { kind: "idle" };
}
/** 管理页的六节。**它们是左栏的第二层,不是正文顶上的一条 tab 带**——
与账户栏那四项是同一种东西(去哪儿),只是矮一级;地址里是 `?tab=`,
刷新、回退、分享链接都落回同一节。左栏(AccountShell)与这一页的标题
读的是同一份,名字只有一处。**label 是函数**:界面语言在运行时可切,
模块顶上取值会把第一次加载时的那门语言焊死 */
export const ADMIN_TABS = [
{ key: "models", label: () => S.settings.tabModels },
{ key: "members", label: () => S.settings.tabMembers },
{ key: "datasources", label: () => S.settings.datasources.tab },
{ key: "sso", label: () => S.settings.tabSso },
{ key: "deployment", label: () => S.settings.tabDeployment },
] as const;
/** 一个源授权给了哪些工作区(0014)。
*
* **授权与挂载是两层**:这里说「这个源可以给谁用」,KB 管理员再在授权过的
* 集合里挑挂不挂。从前没有这一层——可挂载列表返回全部署每一个源,于是任何
* 库的管理员都能把任意生产库挂进自己库。
*
* 两层都是多对多:一个源可授权给多个工作区,一个工作区可拿到多个源。 */
function SourceGrants({ sourceId }: { sourceId: string }) {
const queryClient = useQueryClient();
const [picked, setPicked] = useState("");
const [notice, setNotice] = useState<string | null>(null);
const grants = useQuery({
queryKey: ["dataSourceGrants", sourceId],
queryFn: () => api.dataSourceGrants(sourceId),
});
const workspaces = useQuery({
queryKey: ["workspaces"],
queryFn: api.workspaces,
});
const invalidate = () =>
queryClient.invalidateQueries({ queryKey: ["dataSourceGrants", sourceId] });
const grant = useMutation({
mutationFn: (wsId: string) => api.grantDataSource(sourceId, wsId),
onSuccess: () => {
setPicked("");
setNotice(null);
invalidate();
},
onError: (e: unknown) => toast.error((e as Error).message),
});
const revoke = useMutation({
mutationFn: (wsId: string) => api.revokeDataSource(sourceId, wsId),
// 卸了几个要说出来:收回授权会顺带断掉正在用的挂载,
// 悄悄断比断本身更糟
onSuccess: (r) => {
setNotice(S.settings.datasources.grantRevoked(r.unmounted));
invalidate();
},
onError: (e: unknown) => toast.error((e as Error).message),
});
const granted = grants.data?.workspaces ?? [];
const grantedIds = new Set(granted.map((w) => w.id));
const grantable = (workspaces.data ?? []).filter(
(w) => !grantedIds.has(w.id),
);
return (
<div className="border-t border-line pt-3 space-y-2">
<div className="flex items-baseline gap-2">
<span className="text-fine text-ink-2">
{S.settings.datasources.grants}
</span>
{granted.length === 0 ? (
<span className="text-fine text-ink-2">
{S.settings.datasources.grantsNone}
</span>
) : (
<div className="flex flex-wrap gap-2">
{granted.map((w) => (
<span
key={w.id}
className={chipLike("neutral", "text-fine flex items-center gap-1")}
>
{w.name}
<IconButton size="sm" label={S.settings.datasources.grantRevoke}
disabled={revoke.isPending}
onClick={() => revoke.mutate(w.id)}
>
<X size={10} />
</IconButton>
</span>
))}
</div>
)}
</div>
{grantable.length > 0 && (
<div className="flex items-center gap-2">
<SearchSelect
className="flex-1"
value={picked}
options={grantable.map((w) => ({ value: w.id, label: w.name }))}
onChange={(v) => {
setPicked(v);
if (v) grant.mutate(v);
}}
placeholder={S.settings.datasources.grantAdd}
/>
</div>
)}
{notice && <p className="text-fine text-ink-2">{notice}</p>}
</div>
);
}
/** 部署级配置:注册开关 + worker 并发。 */
export function DeploymentAdmin() {
const queryClient = useQueryClient();
const dep = useQuery({
queryKey: ["deployment"],
queryFn: api.adminDeployment,
});
const [workers, setWorkers] = useState<number | null>(null);
const shown = workers ?? dep.data?.worker_concurrency ?? 64;
// 按模型的并发:缺省值 + 每个在用模型的覆盖
const [modelDefault, setModelDefault] = useState<number | null>(null);
const shownDefault =
modelDefault ?? dep.data?.default_model_concurrency ?? 10;
const [perModel, setPerModel] = useState<Record<string, number>>({});
const save = useMutation({
mutationFn: (v: {
open: boolean;
workers?: number;
defaultModel?: number;
modelLimit?: {
base_url: string;
model: string;
max_concurrent: number | null;
};
ontologyLang?: "en" | "zh";
}) =>
api.saveAdminDeployment(
v.open,
v.workers,
v.defaultModel,
v.modelLimit,
v.ontologyLang,
),
onSuccess: () => {
setPerModel({});
queryClient.invalidateQueries({ queryKey: ["deployment"] });
},
});
const open = dep.data?.open_registration ?? true;
return (
/* 一件事一张卡,与库设置同一副排法。改即生效的(注册开关、默认本体语言)
没有底栏——它们没有"保存"这一步;数字要按一下才算数的,按钮在底栏 */
<div className="space-y-4">
<SettingsCard title={S.settings.cardAccounts}>
<Checkbox
checked={open}
disabled={dep.isPending || save.isPending}
onChange={(v) => save.mutate({ open: v })}
label={S.settings.deployment.openReg}
hint={S.settings.deployment.openRegHint}
/>
</SettingsCard>
{/* 新建库的本体语言。**不是界面语言**——界面语言是每个人自己在账户菜单里选的,
根本不经过后端(docs/decisions/0004)。说明里必须把这句讲出来 */}
<SettingsCard
title={S.settings.deployment.ontologyLang}
hint={S.settings.deployment.ontologyLangHint}
>
<Segmented
size="sm"
className="w-fit"
disabled={dep.isPending || save.isPending}
value={dep.data?.default_ontology_lang ?? "en"}
onChange={(l) => save.mutate({ open, ontologyLang: l })}
options={(["en", "zh"] as const).map((l) => ({
value: l,
label: LANG_NAMES[l],
}))}
/>
</SettingsCard>
<SettingsCard
title={S.settings.deployment.workers}
hint={S.settings.deployment.workersHint}
action={
<>
<Input size="sm" className="u-input-plain w-16 u-num text-center"
type="number"
min={1}
max={256}
value={shown}
disabled={dep.isPending}
onChange={(e) =>
setWorkers(Math.max(1, Math.min(256, Number(e.target.value) || 1)))
}
/>
<Button variant="secondary" size="sm"
disabled={
save.isPending ||
workers === null ||
workers === dep.data?.worker_concurrency
}
onClick={() => save.mutate({ open, workers: shown })}
>
{S.settings.deployment.workersApply}
</Button>
</>
}
/>
{/* 按模型的并发才是真正的节流:约束来自供应商的速率限制,而那是按模型算的。
上面那个 worker 并发只是外层兜底,防任务无限堆积 */}
<SettingsCard
title={S.settings.deployment.modelConcurrency}
hint={S.settings.deployment.modelConcurrencyHint}
note={S.settings.deployment.modelDefault}
action={
<>
<Input size="sm" className="u-input-plain w-16 u-num text-center"
type="number"
min={1}
max={256}
value={shownDefault}
disabled={dep.isPending}
onChange={(e) =>
setModelDefault(
Math.max(1, Math.min(256, Number(e.target.value) || 1)),
)
}
/>
<Button variant="secondary" size="sm"
disabled={
save.isPending ||
modelDefault === null ||
modelDefault === dep.data?.default_model_concurrency
}
onClick={() => save.mutate({ open, defaultModel: shownDefault })}
>
{S.settings.deployment.workersApply}
</Button>
</>
}
>
{/* 在用的模型各自一行:这一行的数字与按钮是这一行的事,不归底栏 */}
{!!dep.data?.models_in_use?.length && (
<div className="divide-y divide-line">
{dep.data.models_in_use.map((m) => {
const cur =
dep.data?.model_limits?.find(
(l) => l.base_url === m.base_url && l.model === m.model,
)?.max_concurrent ?? null;
const key = `${m.base_url}|${m.model}`;
const val = perModel[key] ?? cur ?? shownDefault;
return (
<div
key={key}
className="flex items-center gap-2 py-3 text-small first:pt-0"
>
<span className={chipLike("neutral", "text-fine px-2 shrink-0")}>
{m.kind}
</span>
<span className="font-mono text-ink-2 truncate">{m.model}</span>
<span className="text-ink-2 truncate hidden sm:inline">
{m.base_url}
</span>
{/* 数字框与按钮包成一组,**和底栏那一组同一副几何**
(w-16、gap-3):右缘都顶到卡的内距,间距一差 4px,
同一列上下两个框的左缘就错开,看着就是内距没对齐 */}
<div className="ml-auto flex shrink-0 items-center gap-3">
<Input size="sm" className="u-input-plain w-16 u-num text-center"
type="number"
min={1}
max={256}
value={val}
onChange={(e) =>
setPerModel({
...perModel,
[key]: Math.max(1, Math.min(256, Number(e.target.value) || 1)),
})
}
/>
<Button variant="secondary" size="sm"
disabled={save.isPending || perModel[key] === undefined}
onClick={() =>
save.mutate({
open,
modelLimit: {
base_url: m.base_url,
model: m.model,
max_concurrent: val,
},
})
}
>
{S.settings.deployment.workersApply}
</Button>
{cur !== null && (
<Button variant="secondary" size="sm"
disabled={save.isPending}
title={S.settings.deployment.modelResetHint}
onClick={() =>
save.mutate({
open,
modelLimit: {
base_url: m.base_url,
model: m.model,
max_concurrent: null,
},
})
}
>
{S.settings.deployment.modelReset}
</Button>
)}
</div>
</div>
);
})}
</div>
)}
</SettingsCard>
{save.isError && (
<p className="text-small text-danger">{(save.error as Error).message}</p>
)}
</div>
);
}
/** 知识库管理(部署层):全部库总览 + 新建(建库是管理动作,切换器只切换)。 */
/** 系统层数据源注册(问数):凭据只进不出,列表只显示 host:port/db 摘要。 */
/* ---- 每种引擎问什么,以及那些答案怎么拼成一条连接串 ----
**人填的是字段,存的仍然是连接串。** 服务端一直按 scheme 认引擎(见
`query_engine::engine_from_conn`),所以这里只是把「写一条 URL」这件事
换成「填几格」——密码里的 @ 和 / 也不用人自己转义了。
最后一档是原样的连接串:sslmode、附加参数这类写法拼不出来,得给行家留门。 */
type DsField = {
key: string;
label: string;
placeholder?: string;
optional?: boolean;
secret?: boolean;
};
type EngineSpec = {
id: string;
/** 引擎名是专有名词,不翻译 */
label: string;
fields: DsField[];
/** 从填好的几格拼出连接串。
*
* **拿到的是一张残缺的表**:`values` 里只有人真填过的那几格,刚换到一档
* 引擎时它可能是空的。所以每个 build 都必须容忍缺键——
* 类型写成 `Partial` 而不是 `Record<string, string>`,是因为后者是句假话:
* 索引签名声称取哪个键都是 string,于是 `v.conn.trim()` 编译得过、
* 一选中「连接串」就抛,整页换成错误屏(#573)。
* 其余几档当时没炸,只因为模板串把 `undefined` 安静地拼成了 "undefined"。 */
build: (v: Partial<Record<string, string>>) => string;
};
/** 这两个助手**都收得下缺席的值**,因为表单本来就是一格一格填起来的:
* 刚换到一档引擎时一格都没有。它们的函数体早就按这个写了(`enc` 缺值当空串、
* `auth` 用真值判断),只是签名一直写成 `string`,没把这件事说出来。
* #573 就是从这个缝里掉下去的。 */
const enc = (v?: string) => encodeURIComponent(v ?? "");
/** `user:pass@` 那一段:两处都可能为空(Trino 允许无密码) */
const auth = (user?: string, pass?: string) =>
pass ? `${enc(user)}:${enc(pass)}@` : user ? `${enc(user)}@` : "";
export function dsSpecs(): EngineSpec[] {
const D = S.settings.datasources;
return [
{
id: "postgres",
label: "Postgres",
fields: [
{ key: "host", label: D.fHost, placeholder: "db.internal" },
{ key: "port", label: D.fPort, placeholder: "5432" },
{ key: "database", label: D.fDatabase, placeholder: "analytics" },
{ key: "user", label: D.fUser },
{ key: "password", label: D.fPassword, secret: true },
],
build: (v) =>
`postgres://${auth(v.user, v.password)}${v.host}:${v.port || "5432"}/${enc(v.database)}`,
},
{
id: "mysql",
label: "MySQL",
fields: [
{ key: "host", label: D.fHost, placeholder: "db.internal" },
{ key: "port", label: D.fPort, placeholder: "3306" },
{ key: "database", label: D.fDatabase },
{ key: "user", label: D.fUser },
{ key: "password", label: D.fPassword, secret: true },
],
build: (v) =>
`mysql://${auth(v.user, v.password)}${v.host}:${v.port || "3306"}/${enc(v.database)}`,
},
{
id: "clickhouse",
label: "ClickHouse",
// 用户与库都可以不填:不写用户就是服务器的 default,不写库就读所有非系统库。
// 端口 8443 / 443 服务端自己走 https,表单里不用再问一次
fields: [
{ key: "host", label: D.fHost, placeholder: "ch.internal" },
{ key: "port", label: D.fPort, placeholder: "8123" },
{ key: "database", label: D.fDatabase, optional: true },
{ key: "user", label: D.fUser, optional: true, placeholder: "default" },
{ key: "password", label: D.fPassword, optional: true, secret: true },
],
// 只填了密码就是 default 用户的密码:没有用户名,服务端不会把密码发出去
build: (v) =>
`clickhouse://${auth(v.user || (v.password ? "default" : ""), v.password)}` +
`${v.host}:${v.port || "8123"}` +
(v.database ? `/${enc(v.database)}` : ""),
},
{
id: "trino",
label: "Trino",
fields: [
{ key: "host", label: D.fHost },
{ key: "port", label: D.fPort, placeholder: "8080" },
{ key: "catalog", label: D.fCatalog, placeholder: "iceberg" },
{ key: "schema", label: D.fSchema, optional: true },
{ key: "user", label: D.fUser },
{ key: "password", label: D.fPassword, optional: true, secret: true },
],
build: (v) =>
`trino://${auth(v.user, v.password)}${v.host}:${v.port || "8080"}/${enc(v.catalog)}` +
(v.schema ? `/${enc(v.schema)}` : ""),
},
{
id: "databricks",
label: "Databricks",
fields: [
{ key: "host", label: D.fHost, placeholder: "dbc-1234.cloud.databricks.com" },
{ key: "token", label: D.fToken, secret: true },
{ key: "warehouse", label: D.fWarehouseId, placeholder: "abc123def456" },
{ key: "catalog", label: D.fCatalog, optional: true, placeholder: "main" },
],
build: (v) =>
`databricks://:${enc(v.token)}@${v.host}/sql/1.0/warehouses/${v.warehouse}` +
(v.catalog ? `?catalog=${enc(v.catalog)}` : ""),
},
{
id: "snowflake",
label: "Snowflake",
fields: [
{
key: "account",
label: D.fAccount,
placeholder: "acme-xy12345.snowflakecomputing.com",
},
{ key: "token", label: D.fToken, secret: true },
{ key: "database", label: D.fDatabase },
{ key: "schema", label: D.fSchema },
{ key: "warehouse", label: D.fWarehouse },
],
build: (v) =>
`snowflake://:${enc(v.token)}@${v.account}/${enc(v.database)}/${enc(v.schema)}` +
`?warehouse=${enc(v.warehouse)}`,
},
{
id: "raw",
label: D.engineRaw,
fields: [{ key: "conn", label: D.connString }],
build: (v) => (v.conn ?? "").trim(),
},
];
}
/** 登记一个数据源:选引擎、填几格、**存之前先试一次**。 */
function NewDataSourceDialog({
open,
onOpenChange,
onCreated,
}: {
open: boolean;
onOpenChange: (open: boolean) => void;
onCreated: () => void;
}) {
const specs = dsSpecs();
const [name, setName] = useState("");
const [engineId, setEngineId] = useState(specs[0].id);
const [values, setValues] = useState<Record<string, string>>({});
const spec = specs.find((s) => s.id === engineId) ?? specs[0];
const conn = spec.build(values);
const filled = spec.fields.every((f) => f.optional || (values[f.key] ?? "").trim());
const ready = !!name.trim() && filled;
// 试连不落库,所以换引擎、改字段之后上一次的结果就不作数了
const probe = useMutation({
mutationFn: () => api.adminTestConnString(conn),
});
const create = useMutation({
mutationFn: () => api.adminCreateDataSource({ name: name.trim(), conn_string: conn }),
onSuccess: () => {
setName("");
setValues({});
onCreated();
},
});
// 对话框上一次只说一个结果:试连和新增各有自己的错误,两个都留着就是同一句话出现两次
// (#921)。改字段、换动作,前一个结果就不作数了
const set = (key: string, v: string) => {
probe.reset();
create.reset();
setValues((prev) => ({ ...prev, [key]: v }));
};
return (
<Dialog
open={open}
onOpenChange={onOpenChange}
title={S.settings.datasources.newTitle}
closeLabel={S.ui.close}
width="lg"
footer={
<>
{/* 试连在左边:它不是"完成",是完成之前的那一步 */}
<Button variant="secondary" size="sm" className="mr-auto"
disabled={!filled || probe.isPending}
onClick={() => {
create.reset();
probe.mutate();
}}
>
{probe.isPending
? S.settings.datasources.testing
: S.settings.datasources.testConn}
</Button>
<Button variant="secondary" size="sm" onClick={() => onOpenChange(false)}>
{S.members.cancel}
</Button>
<Button variant="primary" size="sm"
disabled={!ready || create.isPending}
onClick={() => {
probe.reset();
create.mutate();
}}
>
{S.settings.datasources.add}
</Button>
</>
}
>
<div className="space-y-3">
<div className="grid grid-cols-2 gap-3">
<Field label={S.settings.datasources.name} className="mb-0">
<Input className="w-full"
autoFocus
value={name}
onChange={(e) => setName(e.target.value)}
/>
</Field>
<Field label={S.settings.datasources.engine} className="mb-0">
<Dropdown
className="w-full"
value={engineId}
onChange={(v) => {
setEngineId(v);
setValues({});
probe.reset();
create.reset();
}}
options={specs.map((s) => ({ value: s.id, label: s.label }))}
/>
</Field>
</div>
<div className="grid grid-cols-2 gap-3">
{spec.fields.map((f) => (
<Field
key={f.key}
className={`mb-0 ${f.key === "conn" ? "col-span-2" : ""}`}
label={
f.optional
? `${f.label} ${S.settings.datasources.optional}`
: f.label
}
>
<Input className="w-full"
type={f.secret ? "password" : undefined}
autoComplete={f.secret ? "new-password" : "off"}
placeholder={f.placeholder}
value={values[f.key] ?? ""}
onChange={(e) => set(f.key, e.target.value)}
/>
</Field>
))}
</div>
{/* 拼出来的那条串给人看一眼——密码位打码。填错端口、库名多一个斜杠,
在这里一眼就看得出来,不必等到试连 */}
{engineId !== "raw" && filled && (
<p className="truncate font-mono text-fine text-ink-2" title={maskConn(conn)}>
{maskConn(conn)}
</p>
)}
{probe.data && (
<p className={`text-small ${probe.data.ok ? "text-ok" : "text-danger"}`}>
{probe.data.ok
? S.settings.datasources.testOk
: (probe.data.error ?? S.settings.datasources.testFail)}
</p>
)}
{probe.isError && (
<p className="text-small text-danger">{(probe.error as Error).message}</p>
)}
{create.isError && (
<p className="text-small text-danger">{(create.error as Error).message}</p>
)}
</div>
</Dialog>
);
}
/** 回显时把密码位打码:`postgres://user:••••@host/db` */
function maskConn(conn: string): string {
return conn.replace(/:\/\/([^:@/]*):([^@]*)@/, (_m, user: string) =>
user ? `://${user}:••••@` : "://:••••@",
);
}
function DataSourcesAdmin() {
const queryClient = useQueryClient();
const list = useQuery({
queryKey: ["dataSources"],
queryFn: api.adminDataSources,
});
const [creating, setCreating] = useState(false);
// 授权是按工作区的,单租户部署里那一个工作区谁也没见过——所以它不占表里一列,
// 点「可用于」那一格才展开
const [grantsFor, setGrantsFor] = useState<DataSourceView | null>(null);
const invalidate = () =>
queryClient.invalidateQueries({ queryKey: ["dataSources"] });
const remove = useMutation({
mutationFn: (id: string) => api.adminDeleteDataSource(id),
onSettled: invalidate,
});
const test = useMutation({
mutationFn: (id: string) => api.adminTestDataSource(id),
onSettled: invalidate,
});
const rows = list.data?.data_sources ?? [];
return (
<div className="space-y-4">
{/* 登记在名单上面、靠右:动作在内容之前 */}
<div className="flex items-start gap-4">
<p className="min-w-0 flex-1 text-small text-ink-2">
{S.settings.datasources.hint}
</p>
<Button variant="primary" size="sm" className="shrink-0"
onClick={() => setCreating(true)}
>
<Plus size={12} />
{S.settings.datasources.add}
</Button>
</div>
{rows.length === 0 ? (
<div className="glass rounded-panel p-8 text-center text-body text-ink-2">
{S.settings.datasources.empty}
</div>
) : (
<div className="glass rounded-panel overflow-hidden">
<Table>
<THead>
<Tr>
<Th>{S.settings.datasources.name}</Th>
<Th>{S.settings.datasources.engine}</Th>
<Th>{S.settings.datasources.colConn}</Th>
<Th>{S.settings.datasources.grants}</Th>
<Th>{S.settings.datasources.colStatus}</Th>
<Th />
</Tr>
</THead>
<TBody>
{rows.map((d) => (
<Tr key={d.id}>
<Td className="text-ink">{d.name}</Td>
<Td className="text-small text-ink-2">{d.engine}</Td>
<Td
className="max-w-xs truncate font-mono text-small text-ink-2"
title={d.summary}
>
{d.summary}
</Td>
<Td>
<GrantsCell sourceId={d.id} onOpen={() => setGrantsFor(d)} />
</Td>
<Td>
<Chip
tone={
d.last_test_ok === true
? "success"
: d.last_test_ok === false
? "danger"
: "neutral"
}
>
{d.last_test_ok === true
? S.settings.datasources.testOk
: d.last_test_ok === false
? S.settings.datasources.testFail
: S.settings.datasources.neverTested}
</Chip>
</Td>
<Td className="whitespace-nowrap text-right">
<LinkButton
disabled={test.isPending}
onClick={() => test.mutate(d.id)}
>
{S.settings.datasources.test}
</LinkButton>
<LinkButton
tone="danger"
className="ml-3"
disabled={remove.isPending}
onClick={() => remove.mutate(d.id)}
>
{S.settings.datasources.remove}
</LinkButton>
</Td>
</Tr>
))}
</TBody>
</Table>
</div>
)}
<NewDataSourceDialog
open={creating}
onOpenChange={setCreating}
onCreated={() => {
setCreating(false);
invalidate();
}}
/>
<Dialog
open={!!grantsFor}
onOpenChange={(o) => !o && setGrantsFor(null)}
title={grantsFor?.name ?? ""}
description={S.settings.datasources.grantsHint}
closeLabel={S.ui.close}
>
{grantsFor && <SourceGrants sourceId={grantsFor.id} />}
</Dialog>
</div>
);
}
/** 表里那一格:授权给了谁。点它展开授权面板——**没授权要看得见**,
那条源谁也挂不上,而这是它唯一说得出口的地方 */
function GrantsCell({
sourceId,
onOpen,
}: {
sourceId: string;
onOpen: () => void;
}) {
const grants = useQuery({
queryKey: ["dataSourceGrants", sourceId],
queryFn: () => api.dataSourceGrants(sourceId),
});
const names = (grants.data?.workspaces ?? []).map((w) => w.name);
// 没授权是个要紧的状态(谁也挂不上它),用警示胶囊;授权过的只是一句事实
return names.length === 0 ? (
<Chip tone="warn" onClick={onOpen}>
{S.settings.datasources.grantsNoneShort}
</Chip>
) : (
<LinkButton onClick={onOpen} title={names.join(" · ")}>
{S.settings.datasources.grantsCount(names.length)}
</LinkButton>
);
}
const PRESETS: Record<
string,
{ chat: string; embed: string; chatModel: string; embedModel: string }
> = {
DeepSeek: {
chat: "https://api.deepseek.com/v1",
chatModel: "deepseek-chat",
embed: "",
embedModel: "",
},
SiliconFlow: {
chat: "https://api.siliconflow.cn/v1",
chatModel: "deepseek-ai/DeepSeek-V3",
embed: "https://api.siliconflow.cn/v1",
embedModel: "BAAI/bge-m3",
},
"Qwen (DashScope)": {
chat: "https://dashscope.aliyuncs.com/compatible-mode/v1",
chatModel: "qwen-plus",
embed: "https://dashscope.aliyuncs.com/compatible-mode/v1",
embedModel: "text-embedding-v3",
},
Ollama: {
chat: "http://localhost:11434/v1",
chatModel: "qwen2.5:7b",
embed: "http://localhost:11434/v1",
embedModel: "bge-m3",
},
OpenAI: {
chat: "https://api.openai.com/v1",
chatModel: "gpt-4o-mini",
embed: "https://api.openai.com/v1",
embedModel: "text-embedding-3-small",
},
};
export function Settings() {
const { workspace } = useKb();
/* 人在哪一节,**地址说了算**:左栏第二层是一组 Link(见 AccountShell),
刷新、回退、把链接发给同事都落回同一节。从前这里另存一份 state,
于是地址与页面各说各的 */
const { tab: tabParam } = useSearch({ from: "/account/admin" });
const tab = tabParam ?? "models";
const queryClient = useQueryClient();
const settings = useQuery({
queryKey: ["settings", workspace?.id],
queryFn: () => api.settings(workspace!.id),
enabled: !!workspace,
});
const [form, setForm] = useState({
chat_base_url: "",
chat_api_key: "",
chat_model: "",
chat_reasoning_effort: "",
embed_base_url: "",
embed_api_key: "",
embed_model: "",
ocr_provider: "mineru",
ocr_base_url: "",
ocr_api_key: "",
ocr_backend: "",
ocr_model: "",
transcribe_base_url: "",
transcribe_api_key: "",
transcribe_model: "",
});
useEffect(() => {
if (settings.data) {
setForm((f) => ({
...f,
chat_base_url: settings.data.chat_base_url ?? "",
chat_model: settings.data.chat_model ?? "",
chat_reasoning_effort: settings.data.chat_reasoning_effort ?? "",
embed_base_url: settings.data.embed_base_url ?? "",
embed_model: settings.data.embed_model ?? "",
ocr_provider: settings.data.ocr_provider ?? "mineru",
ocr_base_url: settings.data.ocr_base_url ?? "",
ocr_backend: settings.data.ocr_backend ?? "",
ocr_model: settings.data.ocr_model ?? "",
transcribe_base_url: settings.data.transcribe_base_url ?? "",
transcribe_model: settings.data.transcribe_model ?? "",
}));
}
}, [settings.data]);
/** 一张卡一个保存。**PUT 是整体替换**(`llm_settings` 的 upsert 只对两个
密钥做 COALESCE,其余列直接取 EXCLUDED),所以不能只送这张卡的三项——
那会把另一半清成空。底子取服务端那一份、再把这张卡的字段盖上去:
既不会清空邻居,也不会把邻居那张卡还没保存的编辑一起交上去。
密钥不在底子里:留空 = 保留旧密钥,这是 COALESCE 那两列的用法 */
const withSaved = (over: Record<string, unknown>) => ({
chat_base_url: settings.data?.chat_base_url ?? "",
chat_model: settings.data?.chat_model ?? "",
embed_base_url: settings.data?.embed_base_url ?? "",
embed_model: settings.data?.embed_model ?? "",
...over,
});
const usePatch = () =>
// eslint-disable-next-line react-hooks/rules-of-hooks
useMutation({
mutationFn: (patch: Record<string, unknown>) =>
api.saveSettings(workspace!.id, patch),
onSuccess: () =>
queryClient.invalidateQueries({ queryKey: ["settings", workspace?.id] }),
});
const saveChat = usePatch();
const saveEmbed = usePatch();
/* 读扫描件的服务、转写模型各有自己的接口:存它们不经过上面那份整体替换,
所以不用 withSaved 垫底子。回来的 `requeued` 是因为缺它而等着的文件数 */
const saveOcr = useMutation({
mutationFn: () =>
api.saveOcrSettings(workspace!.id, {
provider: form.ocr_provider,
base_url: form.ocr_base_url,
api_key: form.ocr_api_key,
backend: form.ocr_backend,
model: form.ocr_model,
}),
onSuccess: () => {
setDirty((d) => ({ ...d, ocr: false }));
queryClient.invalidateQueries({ queryKey: ["settings", workspace?.id] });
},
});
const saveTranscribe = useMutation({
mutationFn: () =>
api.saveTranscribeSettings(workspace!.id, {
base_url: form.transcribe_base_url,
api_key: form.transcribe_api_key,
model: form.transcribe_model,
}),
onSuccess: () => {
setDirty((d) => ({ ...d, transcribe: false }));
queryClient.invalidateQueries({ queryKey: ["settings", workspace?.id] });
},
});
const resetSaves = () => {
saveChat.reset();
saveEmbed.reset();
saveOcr.reset();
saveTranscribe.reset();
};
const test = useMutation({
mutationFn: () => api.testSettings(workspace!.id),
// 测完谁按的就清掉:pending 的字样只在飞行中属于那张卡
onSettled: () => setTestCard(null),
});
/* 哪张卡按下的"测试"。测一次是两套一起测(一个接口),结果各自回卡;
但两个按钮共用这一个 mutation,从前按任意一张两张一起转"Testing…"(#698) */
const [testCard, setTestCard] = useState<"chat" | "embed" | "ocr" | "transcribe" | null>(
null,
);
/* 两张卡各自有没有改过、还没保存的格子。测试只测已保存的配置,所以有修改的那张卡
不让测,备注改说「先保存」;保存成功才清掉(#698) */
const [dirty, setDirty] = useState({
chat: false,
embed: false,
ocr: false,
transcribe: false,
});
/* 开测:上一轮的结论(两边卡的 Saved/报错、上一轮测试结果)全部让位给这一轮 */
const startTest = () => {
test.reset();
resetSaves();
test.mutate();
};
if (!workspace)
return <div className="p-8 text-body text-ink-2">{S.nav.loading}</div>;
const set =
(k: keyof typeof form) => (e: React.ChangeEvent<HTMLInputElement>) => {
/* 改一格,旧结论全部过期:测试结果、Saved、报错说的都是改之前的那份配置(#698)。
测的永远是已存盘的那份,所以表单一动,卡上就不该再贴任何旧话 */
test.reset();
resetSaves();
// 字段名的前缀就是卡:chat_ / embed_ / ocr_ / transcribe_
setDirty((d) => ({ ...d, [k.split("_")[0]]: true }));
setForm({ ...form, [k]: e.target.value });
};
const label = "block text-small font-medium text-ink-2 mb-1";
/* 两张卡的备注:新测到的盖掉旧保存态,测挂了(连接口都没通)也不再
悄悄退回"Saved"或空白——从前请求本身失败时卡上什么都不说(#698) */
const testTransportError = test.error ? (test.error as Error).message : null;
const chatStatus = modelCardStatus(
test.data
? {
ok: test.data.chat.ok,
message: test.data.chat.ok
? S.settings.ok(test.data.chat.reply ?? "OK")
: (test.data.chat.error ?? ""),
}
: null,
testTransportError,
{
error: saveChat.error ? (saveChat.error as Error).message : null,
saved: saveChat.isSuccess,
dirty: dirty.chat,
},
);
const embedStatus = modelCardStatus(
test.data
? {
ok: test.data.embed.ok,
message: test.data.embed.ok
? S.settings.okDim(test.data.embed.dim ?? 0)
: (test.data.embed.error ?? ""),
}
: null,
testTransportError,
{
error: saveEmbed.error ? (saveEmbed.error as Error).message : null,
saved: saveEmbed.isSuccess,
dirty: dirty.embed,
},
);
const ocrStatus = modelCardStatus(
test.data?.ocr
? {
ok: test.data.ocr.ok,
message: test.data.ocr.ok
? S.settings.okVersion(test.data.ocr.version ?? "?")
: (test.data.ocr.error ?? ""),
}
: null,
testTransportError,
{
error: saveOcr.error ? (saveOcr.error as Error).message : null,
saved: saveOcr.isSuccess,
dirty: dirty.ocr,
},
);
const transcribeStatus = modelCardStatus(
test.data?.transcribe
? {
ok: test.data.transcribe.ok,
message: test.data.transcribe.ok
? S.settings.okReachable
: (test.data.transcribe.error ?? ""),
}
: null,
testTransportError,
{
error: saveTranscribe.error ? (saveTranscribe.error as Error).message : null,
saved: saveTranscribe.isSuccess,
dirty: dirty.transcribe,
},
);
/* 备注的画法四张卡共用:成功走 ok 色、失败走 danger 色——从前成功是中性 accent、
嵌入卡的报错还是正文字色,与本页数据源那节的 ok/danger 不一致(#698) */
const cardNote = (s: ModelCardStatus) =>
s.kind === "idle" ? undefined : s.kind === "saved" ? (
S.settings.saved
) : s.kind === "unsaved" ? (
S.settings.unsaved
) : (
<span className={s.tone}>{s.text}</span>
);
/* 读取模型那两张卡存完多说一句:等着它的文件开始读了几份 */
const readerNote = (s: ModelCardStatus, requeued: number | undefined) =>
s.kind === "saved" && requeued ? S.settings.savedRequeued(requeued) : cardNote(s);
return (
<div className="h-full overflow-y-auto u-scroll px-8 py-6">
{/* 同 KbSettings:设置是读一列字段,居中限宽,行长不随窗口拉长 */}
<div className="mx-auto w-full max-w-4xl">
{/* 标题是这一节的名字,不是「Administration」——左栏已经说了人在
管理区,页顶再说一遍等于每一节的标题都一样 */}
<PageHeader
title={ADMIN_TABS.find((t) => t.key === tab)?.label() ?? S.settings.title}
/>
{tab === "members" && <Members workspaceId={workspace.id} />}
{tab === "datasources" && <DataSourcesAdmin />}
{tab === "sso" && <SsoAdmin />}
{tab === "deployment" && <DeploymentAdmin />}
{tab === "models" && (
/* 两张卡,两个保存:聊天模型与嵌入模型是两套凭据,改一套不该把另一套
一起送上去。服务端对缺席与空串都当"这项不改",所以每张卡只送自己
那三项就够了 */
<div className="space-y-4">
<p className="text-body text-ink-2">{S.settings.modelsIntro}</p>
{/* 预设一按填满两张卡的字段:它不是设置本身,所以在卡外面 */}
<div className="flex flex-wrap gap-2">
{Object.entries(PRESETS).map(([name, p]) => (
<Pill
key={name}
onClick={() => {
/* 预设只是批量填格,和手输一样让旧结论过期 */
test.reset();
resetSaves();
setDirty((d) => ({ ...d, chat: true, embed: true }));
setForm({
...form,
chat_base_url: p.chat,
chat_model: p.chatModel,
embed_base_url: p.embed,
embed_model: p.embedModel,
});
}}
>
{name}
</Pill>
))}
</div>
<SettingsCard
title={S.settings.chatModel}
note={cardNote(chatStatus)}
action={
<>
{/* 试一次连的是两套模型(一个接口),结果各自回到各自那张卡;
但"Testing…"只亮在按下的这一张上(`testCard`) */}
<Button variant="secondary" size="sm"
onClick={() => {
setTestCard("chat");
startTest();
}}
disabled={test.isPending || dirty.chat}
>
{testCard === "chat" && test.isPending ? S.settings.testing : S.settings.test}
</Button>
<Button variant="secondary" size="sm"
onClick={() => {
/* 存盘改了服务端,旧测试结论说的是上一版配置,一起过期 */
test.reset();
saveChat.mutate(
withSaved({
chat_base_url: form.chat_base_url,
chat_model: form.chat_model,
chat_api_key: form.chat_api_key,
chat_reasoning_effort: form.chat_reasoning_effort,
}),
{ onSuccess: () => setDirty((d) => ({ ...d, chat: false })) },
);
}}
disabled={saveChat.isPending}
>
{saveChat.isPending ? S.settings.saving : S.settings.save}
</Button>
</>
}
>
<div className="space-y-3">
<div>
<label className={label}>{S.settings.baseUrl}</label>
<Input
className="w-full"
placeholder="https://api.deepseek.com/v1"
value={form.chat_base_url}
onChange={set("chat_base_url")}
/>
</div>
<div className="grid grid-cols-2 gap-3">
<div>
<label className={label}>{S.settings.model}</label>
<Input
className="w-full"
placeholder="deepseek-chat"
value={form.chat_model}
onChange={set("chat_model")}
/>
</div>
<div>
<label className={label}>{S.settings.reasoningEffort}</label>
{/* 推理模型默认边想边答,抽取一次调用九成的输出是思考。每一种调用都用这一个值;
哪个值关得掉思考看端点(有的认 minimal,有的只认 none)。
小而有界的枚举:Dropdown(web/DESIGN.md 规矩 5,页面上没有原生 select) */}
<Dropdown
className="w-full"
value={form.chat_reasoning_effort}
onChange={(v) => {
setForm((f) => ({ ...f, chat_reasoning_effort: v }));
setDirty((d) => ({ ...d, chat: true }));
}}
options={[
{ value: "", label: S.settings.reasoningDefault },
{ value: "none", label: "none" },
{ value: "minimal", label: "minimal" },
{ value: "low", label: "low" },
{ value: "medium", label: "medium" },
{ value: "high", label: "high" },
]}
/>
<div className="mt-1 text-small text-ink-2">{S.settings.reasoningHint}</div>
</div>
<div>
<label className={label}>
{S.settings.apiKey}{" "}
{settings.data?.has_chat_key && (
<span className="text-accent">{S.settings.keyConfigured}</span>
)}
</label>
<Input
className="w-full"
type="password"
placeholder="sk-…"
value={form.chat_api_key}
onChange={set("chat_api_key")}
/>
</div>
</div>
</div>
</SettingsCard>
<SettingsCard
title={S.settings.embedModel}
note={cardNote(embedStatus)}
action={
<>
<Button variant="secondary" size="sm"
onClick={() => {
setTestCard("embed");
startTest();
}}
disabled={test.isPending || dirty.embed}
>
{testCard === "embed" && test.isPending ? S.settings.testing : S.settings.test}
</Button>
<Button variant="secondary" size="sm"
onClick={() => {
/* 存盘改了服务端,旧测试结论说的是上一版配置,一起过期 */
test.reset();
saveEmbed.mutate(
withSaved({
embed_base_url: form.embed_base_url,
embed_model: form.embed_model,
embed_api_key: form.embed_api_key,
}),
{ onSuccess: () => setDirty((d) => ({ ...d, embed: false })) },
);
}}
disabled={saveEmbed.isPending}
>
{saveEmbed.isPending ? S.settings.saving : S.settings.save}
</Button>
</>
}
>
<div className="space-y-3">
<div>
<label className={label}>{S.settings.baseUrl}</label>
<Input
className="w-full"
placeholder="http://localhost:11434/v1"
value={form.embed_base_url}
onChange={set("embed_base_url")}
/>
</div>
<div className="grid grid-cols-2 gap-3">
<div>
<label className={label}>{S.settings.model}</label>
<Input
className="w-full"
placeholder="bge-m3"
value={form.embed_model}
onChange={set("embed_model")}
/>
</div>
<div>
<label className={label}>
{S.settings.apiKey}{" "}
{settings.data?.has_embed_key && (
<span className="text-accent">{S.settings.keyConfigured}</span>
)}
</label>
<Input
className="w-full"
type="password"
value={form.embed_api_key}
onChange={set("embed_api_key")}
/>
</div>
</div>
</div>
</SettingsCard>
{/* 读取模型:扫描件、图片、录音(0040)。跟上面两张分开讲,因为它们只在
那几类文件上用得到,没配也不影响别的——文件等着,消息中心会说 */}
<h2 className="pt-4 text-title text-ink">{S.settings.readersTitle}</h2>
<p className="text-body text-ink-2">{S.settings.readersIntro}</p>
<SettingsCard
title={S.settings.ocrService}
hint={form.ocr_provider === "ark" ? S.settings.ocrHintArk : S.settings.ocrHint}
note={readerNote(ocrStatus, saveOcr.data?.requeued)}
action={
<>
<Button variant="secondary" size="sm"
onClick={() => {
setTestCard("ocr");
startTest();
}}
disabled={test.isPending || dirty.ocr}
>
{testCard === "ocr" && test.isPending ? S.settings.testing : S.settings.test}
</Button>
<Button variant="secondary" size="sm"
onClick={() => {
test.reset();
saveOcr.mutate();
}}
disabled={saveOcr.isPending}
>
{saveOcr.isPending ? S.settings.saving : S.settings.save}
</Button>
</>
}
>
<div className="space-y-3">
{/* 两种协议(0065):MinerU 交任务再问,方舟把每页送给视觉模型。换一种就是换一家
服务,地址、密钥、模型都不通用,所以切换时整张卡清空重填;服务端也不会把
旧密钥带到新供应商 */}
<div>
<label className={label}>{S.settings.readerProvider}</label>
<Dropdown
className="w-full"
value={form.ocr_provider}
onChange={(v) => {
if (v === form.ocr_provider) return;
test.reset();
resetSaves();
setDirty((d) => ({ ...d, ocr: true }));
setForm({ ...form, ocr_provider: v, ocr_base_url: "", ocr_api_key: "", ocr_backend: "", ocr_model: "" });
}}
options={[
{ value: "mineru", label: "MinerU" },
{ value: "ark", label: S.settings.arkProvider },
]}
/>
</div>
<div>
<label className={label}>{S.settings.serviceUrl}</label>
<Input
className="w-full"
placeholder={form.ocr_provider === "ark" ? "https://ark.cn-beijing.volces.com/api/plan/v3" : "http://localhost:8000"}
value={form.ocr_base_url}
onChange={set("ocr_base_url")}
/>
</div>
<div className="grid grid-cols-2 gap-3">
{form.ocr_provider === "ark" ? (
<div>
<label className={label}>{S.settings.model}</label>
<Input
className="w-full"
placeholder="doubao-seed-2.1-pro"
value={form.ocr_model}
onChange={set("ocr_model")}
/>
</div>
) : (
<div>
<label className={label}>{S.settings.backend}</label>
<Input
className="w-full"
placeholder="vlm-auto-engine"
value={form.ocr_backend}
onChange={set("ocr_backend")}
/>
</div>
)}
<div>
<label className={label}>
{S.settings.apiKey}{" "}
{settings.data?.has_ocr_key && settings.data.ocr_provider === form.ocr_provider && (
<span className="text-accent">{S.settings.keyConfigured}</span>
)}
</label>
<Input
className="w-full"
type="password"
value={form.ocr_api_key}
onChange={set("ocr_api_key")}
/>
</div>
</div>
</div>
</SettingsCard>
<SettingsCard
title={S.settings.transcribeModel}
hint={S.settings.transcribeHint}
note={readerNote(transcribeStatus, saveTranscribe.data?.requeued)}
action={
<>
<Button variant="secondary" size="sm"
onClick={() => {
setTestCard("transcribe");
startTest();
}}
disabled={test.isPending || dirty.transcribe}
>
{testCard === "transcribe" && test.isPending
? S.settings.testing
: S.settings.test}
</Button>
<Button variant="secondary" size="sm"
onClick={() => {
test.reset();
saveTranscribe.mutate();
}}
disabled={saveTranscribe.isPending}
>
{saveTranscribe.isPending ? S.settings.saving : S.settings.save}
</Button>
</>
}
>
<div className="space-y-3">
<div>
<label className={label}>{S.settings.baseUrl}</label>
<Input
className="w-full"
placeholder="https://api.openai.com/v1"
value={form.transcribe_base_url}
onChange={set("transcribe_base_url")}
/>
</div>
<div className="grid grid-cols-2 gap-3">
<div>
<label className={label}>{S.settings.model}</label>
<Input
className="w-full"
placeholder="gpt-4o-transcribe-diarize"
value={form.transcribe_model}
onChange={set("transcribe_model")}
/>
</div>
<div>
<label className={label}>
{S.settings.apiKey}{" "}
{settings.data?.has_transcribe_key && (
<span className="text-accent">{S.settings.keyConfigured}</span>
)}
</label>
<Input
className="w-full"
type="password"
placeholder="sk-…"
value={form.transcribe_api_key}
onChange={set("transcribe_api_key")}
/>
</div>
</div>
</div>
</SettingsCard>
</div>
)}
</div>
</div>
);
}