Skip to content

World's first open-source enterprise world model.

What a long document found (#757)

WaylandYang9468320bbe22
diff --git a/crates/utopia-llm/src/lib.rs b/crates/utopia-llm/src/lib.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.ts
index 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.ts
index 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.tsx
index 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>