World's first open-source enterprise world model.
Rust agent-memorybitemporalgraphragknowledge-baseknowledge-graphllmontologypgvectorpostgresqlragrustself-hostedsemantic-searchtemporal-knowledge-graphworld-model
What a long document found (#757)
WaylandYang9468320bbe22
diff --git a/crates/utopia-llm/src/lib.rs b/crates/utopia-llm/src/lib.rsindex 45005f29..c1ff0221 100644--- a/crates/utopia-llm/src/lib.rs+++ b/crates/utopia-llm/src/lib.rs@@ -103,6 +103,62 @@ pub fn rate_limited(err: &anyhow::Error) -> Option<&RateLimited> {err.chain().find_map(|e| e.downcast_ref::<RateLimited>())}+/// 值得再试一次的那几类失败,连它们各自的「等多久」。**判据是「它会自己好」**:+/// 端点在限流、端点这会儿不可用(502/503/504)、请求根本没送到(连接被重置、响应中断)。+///+/// **读超时不在里面。** `READ_TIMEOUT` 是 300 秒没有第一个字节,重试五次就是 25 分钟;+/// 一个总是超时的调用不会因为多等而变好,它要的是更小的分块或更快的端点。+///+/// 实测一篇 32 块的文档在一小时里两类都撞上:502 四次、连接没送到两次。+pub fn transient(err: &anyhow::Error) -> Option<(&'static str, Option<Duration>)> {+ if let Some(hit) = rate_limited(err) {+ return Some(("端点限流", hit.retry_after));+ }+ if let Some(hit) = unavailable(err) {+ return Some(("端点不可用", hit.retry_after));+ }+ if err.chain().any(|e| e.is::<Interrupted>()) {+ return Some(("流断在半路", None));+ }+ let sending = err+ .chain()+ .find_map(|e| e.downcast_ref::<Unreachable>())+ .filter(|u| !u.0.is_timeout());+ sending.map(|_| ("请求没送到", None))+}++/// 端点开口了又半路没了:流断在一句话中间,既没有 `[DONE]` 也没有 `finish_reason`。+///+/// **做成类型是因为它长得像成功。** 拼到一半的回复是一段合法的字符串,调用方看不出+/// 它本该更长;抽取会把它当成模型给的全部答案,少掉的那些陈述无声无息。+#[derive(Debug, thiserror::Error)]+#[error("LLM stream ended in the middle of the answer ({got} chars in)")]+pub struct Interrupted {+ /// 断掉时已经拼到多少字——报障时它说明「不是一开口就断」+ pub got: usize,+}++/// 端点这会儿不可用:502 / 503 / 504,或者它自己说的 408。**跟 [`RateLimited`] 同一类,+/// 理由也同一条:它会自己好。** 网关抽风、上游重启、排队超时都是几秒到几十秒的事,+/// 而 400(提示词不合法)、401(密钥错)重试一万次还是错。+///+/// 混在 [`Rejected`] 里的代价实测过:本地代理对上游的一次 `fetch failed` 回 502,+/// 32 块的一篇文档里随机几块就此报废,整篇抽取失败重来——一次调用 5% 的失败率,+/// 一篇长文档第一遍几乎必失败(1 − 0.95³² ≈ 81%),而任务只重试三次。+#[derive(Debug, thiserror::Error)]+#[error("LLM endpoint is unavailable ({status}): {detail}")]+pub struct Unavailable {+ pub status: u16,+ /// 端点给的 `Retry-After`(有则更准,多数不给)+ pub retry_after: Option<Duration>,+ pub detail: String,+}++/// anyhow 错误链里的 [`Unavailable`],穿透 context 层。+pub fn unavailable(err: &anyhow::Error) -> Option<&Unavailable> {+ err.chain().find_map(|e| e.downcast_ref::<Unavailable>())+}+/// 账号付不起这次请求:欠费,或者套餐配额用尽。////// **跟 [`RateLimited`] 分开,因为它不会自己好。** 限流等一分钟就过去,@@ -192,6 +248,21 @@ fn failure(detail,});}+ // 网关与排队的那几个:等一等再来。**500 不在里面**——它可以是端点自己的 bug,+ // 重试只是把同一个崩溃再触发一遍+ if matches!(+ status,+ reqwest::StatusCode::REQUEST_TIMEOUT+ | reqwest::StatusCode::BAD_GATEWAY+ | reqwest::StatusCode::SERVICE_UNAVAILABLE+ | reqwest::StatusCode::GATEWAY_TIMEOUT+ ) {+ return anyhow::Error::new(Unavailable {+ status: status.as_u16(),+ retry_after,+ detail,+ });+ }anyhow::Error::new(Rejected {kind: kind.to_string(),status: status.as_u16(),@@ -342,6 +413,107 @@ impl LlmClient {.ok_or_else(|| anyhow::anyhow!("Unexpected LLM response shape: {body}"))}+ /// 一次问答,**走流式但整段返回**:调用方拿到的和 [`Self::chat_at`] 一样是一个+ /// 字符串,区别只在字节怎么到。+ ///+ /// **为什么长提示词的那几条路要用它**:[`READ_TIMEOUT`] 量的是「多久没有新字节」,+ /// 而非流式调用的第一个字节要等模型把整段生成完——于是模型思考的时间全部算作沉默。+ /// 开着推理,一块密集的正文实测首字节 227 秒、偶尔越过 300 秒被判死;同一块流式下+ /// 2.6 秒就有字节(思考过程在流),总时长一样是 230 秒左右。流式不会更快,它让+ /// 「沉默」回到它本来的意思,超时于是只杀真正卡住的请求。+ ///+ /// 思考过程不进返回值:只收 `delta.content`,推理的增量(`reasoning` /+ /// `reasoning_content`)读都不读;`<think>` 混在 content 里的那种照旧由+ /// [`strip_reasoning`] 切掉。+ pub async fn chat_at_streaming(+ &self,+ messages: &[ChatMessage],+ temperature: Option<f32>,+ ) -> anyhow::Result<String> {+ let mut body = json!({+ "model": self.model,+ "messages": messages,+ "stream": true,+ // 用量随最后一帧回来:比较两次运行的第一件事是看 completion token,+ // 换成流式不能把这个数弄丢+ "stream_options": { "include_usage": true },+ });+ if let Some(t) = temperature {+ body["temperature"] = json!(t);+ }+ let resp = self+ .request("/chat/completions")+ .json(&body)+ .send()+ .await+ .map_err(Unreachable)?;+ let status = resp.status();+ let retry_after = retry_after_of(resp.headers());+ if !status.is_success() {+ return Err(response_failure("LLM", status, retry_after, resp).await?);+ }+ let mut bytes = resp.bytes_stream();+ let (mut buf, mut answer) = (String::new(), String::new());+ let (mut saw_frame, mut ended) = (false, false);+ while let Some(part) = bytes.next().await {+ let part = part.map_err(Unreachable)?;+ buf.push_str(&String::from_utf8_lossy(&part));+ // SSE 帧以空行分隔;最后一个不完整的帧留在 buf 里等下一片+ while let Some(pos) = buf.find(+ "++",+ ) {+ let frame = buf[..pos].to_string();+ buf.drain(..pos + 2);+ self.take_frame(&frame, &mut answer, &mut saw_frame, &mut ended);+ }+ }+ // **收尾那一帧也算**:末尾不跟空行的实现有的是,丢掉它就是丢掉答案的尾巴+ let rest = std::mem::take(&mut buf);+ if !rest.trim().is_empty() {+ self.take_frame(&rest, &mut answer, &mut saw_frame, &mut ended);+ }+ if !saw_frame {+ anyhow::bail!("LLM stream carried no frames");+ }+ // 端点开口了又半路没了:拼到一半的回复长得像成功,不做成错误就会被当成+ // 模型给的全部答案+ if !ended {+ return Err(anyhow::Error::new(Interrupted { got: answer.len() }));+ }+ Ok(strip_reasoning(&answer).to_string())+ }++ /// 一个 SSE 帧:取内容增量、认终止信号、顺手记用量。推理的增量读都不读。+ fn take_frame(&self, frame: &str, answer: &mut String, saw_frame: &mut bool, ended: &mut bool) {+ for line in frame.lines() {+ let Some(data) = line.strip_prefix("data:").map(str::trim) else {+ continue;+ };+ if data == "[DONE]" {+ *ended = true;+ continue;+ }+ let Ok(v) = serde_json::from_str::<serde_json::Value>(data) else {+ continue;+ };+ *saw_frame = true;+ if let Some(delta) = v["choices"][0]["delta"]["content"].as_str() {+ answer.push_str(delta);+ }+ // 模型自己说完了:正常收尾(stop)或撞上它的输出上限(length),两种都是+ // 端点把话说完了,与「流断在半路」不同+ if v["choices"][0]["finish_reason"].is_string() {+ *ended = true;+ }+ // 用量只在最后一帧(choices 为空)出现+ if !v["usage"].is_null() {+ log_usage(&self.model, &v);+ }+ }+ }+/// 工具对话(非流式):messages 为 OpenAI 协议原始 JSON/// (支持 assistant.tool_calls 与 role=tool 回合),tools 为 function 定义数组。pub async fn chat_tools(@@ -781,6 +953,161 @@ mod tests {assert!(error.to_string().contains(diagnosis), "{error:#}");}+ /// 流式的一次问答收成整段:只要 `delta.content`,推理的增量不进返回值,+ /// 用量那一帧不当内容,没有一帧是错(端点开了流却什么都没发)+ #[tokio::test]+ async fn a_streamed_answer_arrives_whole_without_its_reasoning() {+ let sse = [+ "data: {\"choices\":[{\"delta\":{\"reasoning_content\":\"thinking hard\"}}]}",+ "data: {\"choices\":[{\"delta\":{\"content\":\"{\\\"e\\\":[\"}}]}",+ "data: {\"choices\":[{\"delta\":{\"content\":\"]}\"}}]}",+ "data: {\"choices\":[],\"usage\":{\"prompt_tokens\":10,\"completion_tokens\":9000}}",+ "data: [DONE]",+ "",+ ]+ .join(+ "++",+ );+ let (addr, server) = an_http_response("200 OK", "text/event-stream", &sse).await;+ let answer = client_at(addr)+ .chat_at_streaming(+ &[ChatMessage {+ role: "user".into(),+ content: "hi".into(),+ }],+ Some(0.0),+ )+ .await+ .unwrap();+ server.await.unwrap();+ assert_eq!(answer, "{\"e\":[]}", "只收 content 的增量,拼成整段");++ // 开了流却一帧都没发:那不是空答案,那是没答+ // 末帧不跟空行:尾巴不能丢+ let tail = "data: {\"choices\":[{\"delta\":{\"content\":\"head\"}}]}++data: {\"choices\":[{\"delta\":{\"content\":\"tail\"},\"finish_reason\":\"stop\"}]}";+ let (addr, server) = an_http_response("200 OK", "text/event-stream", tail).await;+ let answer = client_at(addr)+ .chat_at_streaming(+ &[ChatMessage {+ role: "user".into(),+ content: "hi".into(),+ }],+ None,+ )+ .await+ .unwrap();+ server.await.unwrap();+ assert_eq!(answer, "headtail", "最后一帧没有空行收尾,也要算进去");++ // 开口了又半路没了:那不是一个短答案,那是没答完,值得再试一次+ let cut = "data: {\"choices\":[{\"delta\":{\"content\":\"half an ans\"}}]}++";+ let (addr, server) = an_http_response("200 OK", "text/event-stream", cut).await;+ let err = client_at(addr)+ .chat_at_streaming(+ &[ChatMessage {+ role: "user".into(),+ content: "hi".into(),+ }],+ None,+ )+ .await+ .expect_err("断在半路该是错误");+ server.await.unwrap();+ assert_eq!(+ crate::transient(&err).map(|(w, _)| w),+ Some("流断在半路"),+ "{err:#}"+ );++ let (addr, server) = an_http_response("200 OK", "text/event-stream", "").await;+ let err = client_at(addr)+ .chat_at_streaming(+ &[ChatMessage {+ role: "user".into(),+ content: "hi".into(),+ }],+ None,+ )+ .await+ .expect_err("没有帧该是错误");+ server.await.unwrap();+ assert!(format!("{err:#}").contains("no frames"), "{err:#}");+ }++ /// 会自己好的与不会自己好的分开:网关那几个是 [`Unavailable`],密钥错那类照旧+ /// 是 [`Rejected`],欠费与限流各归各位。调用方据此决定「等一会儿再来」还是「这块废了」+ #[tokio::test]+ async fn a_gateway_failure_is_transient_and_a_bad_key_is_not() {+ for status in [+ "502 Bad Gateway",+ "503 Service Unavailable",+ "504 Gateway Timeout",+ "408 Request Timeout",+ ] {+ let (addr, server) = an_http_response(status, "text/plain", "upstream hiccup").await;+ let err = client_at(addr)+ .chat(&[ChatMessage {+ role: "user".into(),+ content: "hi".into(),+ }])+ .await+ .expect_err("非成功状态该是错误");+ server.await.unwrap();+ let hit = crate::unavailable(&err)+ .unwrap_or_else(|| panic!("{status} 该是会自己好的那一类:{err:#}"));+ assert_eq!(hit.status, status[..3].parse::<u16>().unwrap());+ assert!(+ format!("{err:#}").contains("upstream hiccup"),+ "原话要带出来:{err:#}"+ );+ }++ // 请求根本没送到(连不上):也是会自己好的一类+ let nowhere = ChatMessage {+ role: "user".into(),+ content: "hi".into(),+ };+ let dead = LlmClient::new("http://127.0.0.1:1", None, "m");+ let err = dead.chat(&[nowhere]).await.expect_err("连不上该是错误");+ assert!(crate::is_unreachable(&err), "{err:#}");+ assert_eq!(+ crate::transient(&err).map(|(w, _)| w),+ Some("请求没送到"),+ "{err:#}"+ );++ // 密钥错、请求不合法:重试一万次还是错,不能混进去+ for status in [+ "401 Unauthorized",+ "400 Bad Request",+ "500 Internal Server Error",+ ] {+ let (addr, server) = an_http_response(status, "text/plain", "no").await;+ let err = client_at(addr)+ .chat(&[ChatMessage {+ role: "user".into(),+ content: "hi".into(),+ }])+ .await+ .expect_err("非成功状态该是错误");+ server.await.unwrap();+ assert!(+ crate::unavailable(&err).is_none(),+ "{status} 不该被当成会自己好的:{err:#}"+ );+ assert!(+ crate::rate_limited(&err).is_none(),+ "{status} 不是限流:{err:#}"+ );+ }+ }+/// #527 的正题:一个回纯文本的 502,五条请求路径(对话、工具对话、两种流式、嵌入)/// 都要把那句话原样带出来,而不是报「unknown error」或「连不上」。#[tokio::test]diff --git a/crates/utopia-server/src/api/ontology_routes.rs b/crates/utopia-server/src/api/ontology_routes.rsindex f6770bef..6a4eeaf4 100644--- a/crates/utopia-server/src/api/ontology_routes.rs+++ b/crates/utopia-server/src/api/ontology_routes.rs@@ -139,10 +139,12 @@ pub async fn create_entity_type().await;// 本体多了一个类:类别词的绑定里那些「没有」和「没定」的要重判(0044 对齐第一片)- let _ = utopia_store::jobs::enqueue_unless_queued(+ let _ = utopia_store::jobs::enqueue_unless_pending(&state.pool,"align_types",json!({ "kb_id": kb_id }),+ // 去抖:一批编辑(导一个包、建一串属性)只排一次+ std::time::Duration::from_secs(5),).await;Ok(Json(json!({ "id": id })))@@ -184,10 +186,12 @@ pub async fn update_entity_type().await;// 类的定义改了:绑到它的类别词过期,重判- let _ = utopia_store::jobs::enqueue_unless_queued(+ let _ = utopia_store::jobs::enqueue_unless_pending(&state.pool,"align_types",json!({ "kb_id": kb_id }),+ // 去抖:一批编辑(导一个包、建一串属性)只排一次+ std::time::Duration::from_secs(5),).await;Ok(Json(json!({ "ok": true })))@@ -324,10 +328,12 @@ pub async fn create_relation_type(utopia_store::ontology::set_relation_qualifiers(&state.pool, kb_id, id, q).await?;}// 多了一个属性:判成 none / undecided 的签名也许对得上了(0044 对齐第二片)- utopia_store::jobs::enqueue_unless_queued(+ utopia_store::jobs::enqueue_unless_pending(&state.pool,"align_phrases",serde_json::json!({ "kb_id": kb_id }),+ // 去抖:一批编辑(导一个包、建一串属性)只排一次+ std::time::Duration::from_secs(5),).await?;let _ = utopia_store::audit::record(@@ -369,10 +375,12 @@ pub async fn update_relation_type(utopia_store::ontology::set_relation_qualifiers(&state.pool, kb_id, id, q).await?;}// 属性改了定义或域/值域:绑到它的签名过期,判成 none 的也许对得上了- utopia_store::jobs::enqueue_unless_queued(+ utopia_store::jobs::enqueue_unless_pending(&state.pool,"align_phrases",serde_json::json!({ "kb_id": kb_id }),+ // 去抖:一批编辑(导一个包、建一串属性)只排一次+ std::time::Duration::from_secs(5),).await?;let _ = utopia_store::audit::record(diff --git a/crates/utopia-server/src/extraction.rs b/crates/utopia-server/src/extraction.rsindex 887aa3e9..ecb0e129 100644--- a/crates/utopia-server/src/extraction.rs+++ b/crates/utopia-server/src/extraction.rs@@ -55,27 +55,34 @@ pub(crate) async fn chat_retrying_rate_limits_at() -> anyhow::Result<String> {let mut backoff = Duration::from_secs(2);for attempt in 1..=RATE_LIMIT_TRIES {- // 许可只包住调用本身,出了这个块就还回去+ // 许可只包住调用本身,出了这个块就还回去。+ //+ // **走流式**:这条路上的提示词都长(抽取一整块、对齐一批签名),开着推理时+ // 模型先想几分钟再开口,而非流式下那几分钟在传输层看来是彻底的沉默,读超时+ // 会把正常的调用判死(实测一块正文首字节 227 秒,偶尔越过 300 秒)。流式下+ // 思考过程就是字节,超时于是只杀真正卡住的请求。返回值仍是整段let outcome = {let _permit = llm_util::acquire_chat(state, settings).await;- client.chat_at(messages, temperature).await+ client.chat_at_streaming(messages, temperature).await};let err = match outcome {Ok(reply) => return Ok(reply),Err(e) => e,};- let Some(hit) = utopia_llm::rate_limited(&err) else {+ // 会自己好的那几类(限流、端点不可用、请求没送到)退避重试,其余照原样抛出去+ let Some((what, retry_after)) = utopia_llm::transient(&err) else {return Err(err);};if attempt == RATE_LIMIT_TRIES {- return Err(err.context(format!("限流退避 {RATE_LIMIT_TRIES} 次仍未通过")));+ return Err(err.context(format!("{what}退避 {RATE_LIMIT_TRIES} 次仍未通过")));}- let delay = jitter(hit.retry_after.unwrap_or(backoff).min(RATE_LIMIT_CAP));+ let delay = jitter(retry_after.unwrap_or(backoff).min(RATE_LIMIT_CAP));tracing::warn!(attempt,delay_ms = delay.as_millis() as u64,- from_header = hit.retry_after.is_some(),- "端点限流,退避后重试"+ from_header = retry_after.is_some(),+ why = what,+ "端点这次没答成,退避后重试");tokio::time::sleep(delay).await;backoff = (backoff * 2).min(RATE_LIMIT_CAP);diff --git a/crates/utopia-server/src/extraction_open.rs b/crates/utopia-server/src/extraction_open.rsindex 932a8ea0..b6d2da2d 100644--- a/crates/utopia-server/src/extraction_open.rs+++ b/crates/utopia-server/src/extraction_open.rs@@ -215,6 +215,15 @@ pub(crate) async fn run_open(Ok(r) => r,Err(e) => {tracing::warn!(%document_id, seq = chunk.seq, error = %e, "开放抽取调用失败,跳过该分块");+ drop_signal(+ state,+ kb_id,+ document_id,+ reason::CHUNK_UNEXTRACTED,+ "调用失败,这一块没有进图",+ Some(&format!("#{}:{e}", chunk.seq)),+ )+ .await;unextracted.push((chunk.seq, format!("调用失败:{e}")));continue;}@@ -224,6 +233,15 @@ pub(crate) async fn run_open(Ok(x) => x,Err(e) => {tracing::warn!(%document_id, seq = chunk.seq, error = %e, "开放抽取回复解析失败,跳过该分块");+ drop_signal(+ state,+ kb_id,+ document_id,+ reason::CHUNK_UNEXTRACTED,+ "回复解析不了,这一块没有进图",+ Some(&format!("#{}:{e}", chunk.seq)),+ )+ .await;unextracted.push((chunk.seq, format!("回复解析失败:{e}")));continue;}diff --git a/crates/utopia-server/src/phrase_alignment.rs b/crates/utopia-server/src/phrase_alignment.rsindex dc520939..827a7f32 100644--- a/crates/utopia-server/src/phrase_alignment.rs+++ b/crates/utopia-server/src/phrase_alignment.rs@@ -86,7 +86,6 @@ async fn align_phrases_locked(client: &utopia_llm::LlmClient,) -> anyhow::Result<()> {let pool = &state.pool;- let run_started = chrono::Utc::now();let props = utopia_store::ontology::relation_type_views(pool, kb_id).await?;let classes = utopia_store::graph::entity_types(pool, kb_id).await?;let class_key: HashMap<Uuid, &str> = classes.iter().map(|c| (c.id, c.key.as_str())).collect();@@ -314,6 +313,8 @@ async fn align_phrases_locked(// 这一轮跑着的时候世界没停:新文档带来新签名,改了的属性让刚判的绑定过期,本轮没排上// 的触发也都落在这里。有失败的批次、有没试过的新签名、有本轮判完又过期的绑定,就再排// 一次+ // 「过期」不限本轮判的:跑着的时候有人建了属性,判过 none 的老绑定也该再判一次+ // ——那正是批量建本体时唯一的触发(建的时候有一份在跑,就不再排了)let again = failed > 0|| phrase_bindings::signatures(pool, kb_id).await?@@ -322,7 +323,7 @@ async fn align_phrases_locked(|| phrase_bindings::stale(pool, kb_id).await?.iter()- .any(|b| b.decided_by != "person" && b.decided_at >= run_started);+ .any(|b| b.decided_by != "person");if again {utopia_store::jobs::enqueue_unless_queued(pool,diff --git a/crates/utopia-server/src/type_alignment.rs b/crates/utopia-server/src/type_alignment.rsindex 975987d4..0d0f4a57 100644--- a/crates/utopia-server/src/type_alignment.rs+++ b/crates/utopia-server/src/type_alignment.rs@@ -109,7 +109,6 @@ async fn align_types_locked(client: &utopia_llm::LlmClient,) -> anyhow::Result<()> {let pool = &state.pool;- let run_started = chrono::Utc::now();let classes = utopia_store::graph::entity_types(pool, kb_id).await?;let by_id: HashMap<Uuid, &EntityType> = classes.iter().map(|c| (c.id, c)).collect();let by_key: HashMap<&str, &EntityType> = classes.iter().map(|c| (c.key.as_str(), c)).collect();@@ -311,6 +310,7 @@ async fn align_types_locked(state.emit_graph(kb_id);}// 同短语对齐:失败过、来了没试过的新词、本轮判完的又过期了,就再排一次+ // 同短语对齐:「过期」不限本轮判的,跑着时建的类也要让老绑定再判一次let again = failed > 0 || {let stale_now: HashSet<String> = type_bindings::stale(pool, kb_id).await?@@ -320,11 +320,10 @@ async fn align_types_locked(.await?.iter().any(|s| !attempted.contains(&s.kind_word) && !existing.contains_key(&s.kind_word))- || type_bindings::bindings(pool, kb_id).await?.iter().any(|b| {- b.decided_by != "person"- && b.decided_at >= run_started- && stale_now.contains(&b.kind_word)- })+ || type_bindings::bindings(pool, kb_id)+ .await?+ .iter()+ .any(|b| b.decided_by != "person" && stale_now.contains(&b.kind_word))};if again {utopia_store::jobs::enqueue_unless_queued(diff --git a/crates/utopia-store/src/extraction_drops.rs b/crates/utopia-store/src/extraction_drops.rsindex 12c575cf..e25d92b4 100644--- a/crates/utopia-store/src/extraction_drops.rs+++ b/crates/utopia-store/src/extraction_drops.rs@@ -15,6 +15,12 @@ use uuid::Uuid;/// 原因码。前端按这个查文案,所以是稳定契约,不要改字面量。/// 都由开放抽取那条路(0044)发出;类型化那条路的原因码随它一起退场了pub mod reason {+ /// 这一块整个没抽成:调用失败(端点不可用、请求没送到、等太久)或回复解析不了。+ ///+ /// **与别的原因码不同,它丢的是一整块原文,不是一条陈述。** 任务的 `last_error`+ /// 里也有这句话,可那是给排查的人看的;文档抽完之后还能看见「这一块没进去」的,+ /// 只有这张表(0001:丢弃是一行,不是沉默)+ pub const CHUNK_UNEXTRACTED: &str = "chunk_unextracted";/// 陈述缺宾语也缺值pub const OBJECT_MISSING: &str = "object_missing";/// 模型给的这一条不合结构(缺短语之类)→ 只跳这一条,不牵连整块diff --git a/crates/utopia-store/src/jobs.rs b/crates/utopia-store/src/jobs.rsindex 6973d486..653abab6 100644--- a/crates/utopia-store/src/jobs.rs+++ b/crates/utopia-store/src/jobs.rs@@ -26,6 +26,43 @@ pub struct Job {/// 同种任务、同样载荷已经排着就不再排:一批文档各自抽完都想触发同一个库级任务/// (类型消解、对账),排十次跑十次是浪费,而且后九次看到的是第一次跑完的库。/// 返回 None = 已有一条在排队+/// 排一件事,除非同样的一件**已经排着或正在跑**。+///+/// 与 [`enqueue_unless_queued`] 的差别只在「正在跑」那一半,而那一半正是批量编辑+/// 会踩的:本体页一口气建 28 条属性,每建一条排一次,第一条开跑之后的 27 条都不再+/// 与「排着的」撞上,于是排成 28 份,串行跑 28 遍。用这个入口的任务必须在**结束时+/// 自己回头看有没有新活**(对齐的两个任务都这么做),否则跑着时来的那些变化会丢。+///+/// `after` 是**去抖**:一批编辑里第一条排下一个几秒后才跑的任务,其余每一条都撞上+/// 这个「排着的」而不再排。没有它,空库上一次运行只要几百毫秒,42 次创建照样排出+/// 十几份——「正在跑」这一半只有在任务真的在跑时才挡得住。+pub async fn enqueue_unless_pending(+ pool: &PgPool,+ kind: &str,+ payload: serde_json::Value,+ after: Duration,+) -> AppResult<Option<i64>> {+ let mut tx = pool.begin().await?;+ let row: Option<(i64,)> = sqlx::query_as(+ "INSERT INTO jobs (kind, payload, run_at)+ SELECT $1, $2, now() + make_interval(secs => $3)+ WHERE NOT EXISTS (SELECT 1 FROM jobs+ WHERE kind = $1 AND payload = $2+ AND status IN ('queued', 'running'))+ RETURNING id",+ )+ .bind(kind)+ .bind(payload)+ .bind(after.as_secs_f64())+ .fetch_optional(&mut *tx)+ .await?;+ if row.is_some() {+ notify_worker_tx(&mut tx).await?;+ }+ tx.commit().await?;+ Ok(row.map(|(id,)| id))+}+pub async fn enqueue_unless_queued(pool: &PgPool,kind: &str,diff --git a/web/src/i18n/en.ts b/web/src/i18n/en.tsindex 97f3de70..cd682c8f 100644--- a/web/src/i18n/en.ts+++ b/web/src/i18n/en.ts@@ -509,6 +509,7 @@ export const en = {quote_not_in_chunk: "Kept, but the quoted sentence is not in the text verbatim",time_not_in_quote: "A time mention's words are not in the text",unknown_ref: "The item points at nothing in the reply",+ chunk_unextracted: "A passage the endpoint could not answer for",phrase_is_value: "Kept, but the phrase is the value itself",phrase_is_subject: "Kept, but the phrase is the subject's own name",} as Record<string, string>,@@ -925,6 +926,10 @@ export const en = {shownName: "shown name",nameUntil: (d: string) => `until ${d}`,removeName: "Remove",+ // 问一句再移除:名字是事实,界面上没有再加回来的地方+ removeNameAsk: "Remove this name?",+ removeNameCancel: "Keep",+ removeNameGo: "Remove",nameRemoved: "Name removed",timelineEmpty: "No dated facts yet.",lastConfirmed: (d: string) => `confirmed ${d}`,diff --git a/web/src/i18n/zh.ts b/web/src/i18n/zh.tsindex bf06da9d..1804bc1b 100644--- a/web/src/i18n/zh.ts+++ b/web/src/i18n/zh.ts@@ -460,6 +460,7 @@ export const zh: Strings = {quote_not_in_chunk: "已保留,但引文不是原文原样",time_not_in_quote: "时间词不在原文里",unknown_ref: "这一条指向的东西不在回复里",+ chunk_unextracted: "这一段端点没能答上,没有进图",phrase_is_value: "已保留,但短语就是那个值",phrase_is_subject: "已保留,但短语就是主语的名字",},@@ -833,6 +834,9 @@ export const zh: Strings = {shownName: "显示名",nameUntil: (d) => `至 ${d}`,removeName: "移除",+ removeNameAsk: "移除这个名字?",+ removeNameCancel: "留着",+ removeNameGo: "移除",nameRemoved: "已移除这个名字",timelineEmpty: "还没有带日期的事实。",lastConfirmed: (d: string) => `${d} 确认`,diff --git a/web/src/pages/Graph.tsx b/web/src/pages/Graph.tsxindex 2c675e0f..73e16a46 100644--- a/web/src/pages/Graph.tsx+++ b/web/src/pages/Graph.tsx@@ -3122,6 +3122,11 @@ function NameSection({names: NameView[];}) {const [open, setOpen] = useState(true);+ /* 移除一个名字要问一句,**第二下落在另一个按钮上**——同图谱页重推推理那一处的+ 手势(同一个控件连点两下在这产品里一直是「收回去」)。够不上 DangerConfirm 那一+ 档(红标题、逐字输入,留给删库),但也不能一点就走:名字是事实(0041),移除是+ 把那条 `known_as` 作废,**而界面上没有再加回名字的地方**——点错了只能重抽文档 */+ const [armed, setArmed] = useState<string | null>(null);const qc = useQueryClient();const remove = useMutation({mutationFn: (factId: string) => api.rejectFact(kbId, factId),@@ -3165,15 +3170,35 @@ function NameSection({{n.canonical && <span>{S.graph.shownName}</span>}{until && <span className="u-num">{S.graph.nameUntil(until)}</span>}{n.evidence_count > 0 && <span>{S.graph.sources(n.evidence_count)}</span>}- {!n.canonical && (- <LinkButton- className={cn(REVEAL, "ml-auto text-fine")}- disabled={remove.isPending}- onClick={() => remove.mutate(n.fact_id)}- >- {S.graph.removeName}- </LinkButton>- )}+ {!n.canonical &&+ (armed === n.fact_id ? (+ /* 问句与两个目标就地展开:一行之内换不了别的排布,而问句+ 必须和它问的那个名字在同一行,否则「移除哪一个」得靠记 */+ <span className="ml-auto flex items-center gap-2 text-fine">+ <span className="text-ink-2">{S.graph.removeNameAsk}</span>+ <LinkButton onClick={() => setArmed(null)}>+ {S.graph.removeNameCancel}+ </LinkButton>+ <LinkButton+ className="text-danger"+ disabled={remove.isPending}+ onClick={() => {+ setArmed(null);+ remove.mutate(n.fact_id);+ }}+ >+ {S.graph.removeNameGo}+ </LinkButton>+ </span>+ ) : (+ <LinkButton+ className={cn(REVEAL, "ml-auto text-fine")}+ disabled={remove.isPending}+ onClick={() => setArmed(n.fact_id)}+ >+ {S.graph.removeName}+ </LinkButton>+ ))}</span></span></div>