@@ -209,31 +328,89 @@ def home() -> bytes:
-
最近任务
-
读取中…
"""
+
+
+
+
任务列表
+
+
+
+
+
+
"""
script = """"""
+ return shell("模型与系统配置", body, script)
+
+
+def _probe_litellm_models() -> dict[str, Any]:
+ try:
+ url = f"{CFG.litellm_base_url}/models"
+ req = urllib.request.Request(
+ url,
+ headers={"Authorization": f"Bearer {CFG.api_key()}", "Accept": "application/json"},
+ )
+ with urllib.request.urlopen(req, timeout=8) as resp:
+ data = json.loads(resp.read().decode("utf-8", errors="ignore"))
+ models = sorted({str(m.get("id")) for m in (data.get("data") or []) if m.get("id")})
+ return {"ok": True, "models": models}
+ except Exception as exc:
+ return {"ok": False, "error": str(exc), "models": []}
class Handler(BaseHTTPRequestHandler):
- server_version = "ASRService/2"
+ server_version = "ASRService/3"
def log_message(self, *_):
pass
@@ -531,6 +1129,11 @@ class Handler(BaseHTTPRequestHandler):
self.end_headers()
self.wfile.write(data)
+ def redirect(self, location: str) -> None:
+ self.send_response(303)
+ self.send_header("Location", location)
+ self.end_headers()
+
def json(self, obj: object, status: int = 200) -> None:
self.send_data(
json.dumps(obj, ensure_ascii=False).encode("utf-8"),
@@ -563,9 +1166,7 @@ class Handler(BaseHTTPRequestHandler):
def need_web_auth(self) -> bool:
if self.web_authed():
return True
- self.send_response(303)
- self.send_header("Location", "/login")
- self.end_headers()
+ self.redirect("/login")
return False
def need_auth(self) -> bool:
@@ -577,6 +1178,11 @@ class Handler(BaseHTTPRequestHandler):
def header(self, name: str, limit: int) -> str:
return safe(urllib.parse.unquote(self.headers.get(name, "")), limit)
+ def read_form(self, max_bytes: int = 65536) -> dict[str, list[str]]:
+ length = min(int(self.headers.get("Content-Length", "0")), max_bytes)
+ raw = self.rfile.read(length).decode("utf-8", errors="ignore") if length > 0 else ""
+ return urllib.parse.parse_qs(raw, keep_blank_values=True)
+
def upload(self, source: str, protected: bool) -> None:
if protected and not self.auth():
return self.json({"error": "unauthorized"}, 401)
@@ -595,7 +1201,7 @@ class Handler(BaseHTTPRequestHandler):
jid = uuid.uuid4().hex[:24]
title = self.header("X-Title", 80)
prov = providers.normalize_provider_name(
- self.header("X-ASR-Provider", 40) or DEFAULT_PROVIDER
+ self.header("X-ASR-Provider", 40) or CFG.asr_provider
)
model = self.header("X-ASR-Model", 80)
stored = f"{time.strftime('%Y-%m-%d_%H_%M_%S')}-{stem(title or Path(name).stem)}-{jid[:8]}{suffix}"
@@ -691,6 +1297,7 @@ class Handler(BaseHTTPRequestHandler):
def do_GET(self) -> None:
parsed = urllib.parse.urlsplit(self.path)
path = parsed.path
+ q = urllib.parse.parse_qs(parsed.query)
if path in ("/health", "/healthz"):
return self.json({"ok": True, "service": "asr-web"})
if path == "/readyz":
@@ -706,18 +1313,28 @@ class Handler(BaseHTTPRequestHandler):
if path == "/api/v1/providers":
if not self.need_auth():
return
- return self.json({"providers": providers.provider_status()})
+ return self.json({"providers": providers.provider_status(), "default": CFG.asr_provider})
+ if path == "/api/v1/settings":
+ if not self.need_auth():
+ return
+ raw_s = db.get_all_settings()
+ redacted = {
+ k: (_mask_secret(v) if k.endswith("_api_key") else v)
+ for k, v in raw_s.items()
+ }
+ return self.json({"settings": redacted})
if path == "/api/v1/jobs":
if not self.need_auth():
return
- q = urllib.parse.parse_qs(parsed.query)
return self.json({
"jobs": [
public(x)
for x in db.list_jobs(
- int(q.get("limit", [30])[0]),
- int(q.get("offset", [0])[0]),
+ int(q.get("limit", ["30"])[0]),
+ int(q.get("offset", ["0"])[0]),
q.get("status", [""])[0],
+ q.get("q", [""])[0],
+ q.get("provider", [""])[0],
)
]
})
@@ -751,83 +1368,139 @@ class Handler(BaseHTTPRequestHandler):
})
return self.json({"reviews": rows})
- # Web UI routes below (check optional web password)
+ # Web UI routes below
if not self.need_web_auth():
return
if path == "/":
- return self.send_data(home())
+ return self.send_data(home(q.get("msg", [""])[0]))
if path == "/review/":
- return self.send_data(review_page(None))
+ return self.send_data(review_page(None, q.get("msg", [""])[0]))
if path == "/lexicon":
- return self.send_data(lexicon_page())
+ return self.send_data(
+ lexicon_page(
+ tab=q.get("tab", ["aliases"])[0],
+ q=q.get("q", [""])[0],
+ msg=q.get("msg", [""])[0],
+ )
+ )
if path == "/settings":
- return self.send_data(settings_page())
+ return self.send_data(settings_page(q.get("msg", [""])[0]))
+ if path == "/settings/models-probe":
+ return self.json(_probe_litellm_models())
if path == "/docs":
- return self.send_data(shell(
- "Agent API",
- "
Agent API
"
- "所有 /api/v1/* 接口使用 Authorization: Bearer $ASR_AGENT_TOKEN。
"
- "POST /api/v1/jobs：二进制流上传录音，支持请求头 X-Filename、X-Title、X-Context、X-ASR-Provider (qwen3cam|soniox|gemini|openai|grok)、X-ASR-Model。GET /api/v1/jobs & GET /api/v1/jobs/{id}：查询任务与事件。GET /api/v1/jobs/{id}/reviews & POST /api/v1/jobs/{id}/reviews/{qid}：读取与提交人工确认。POST /api/v1/jobs/{id}/retry：支持传入 {\"provider\":\"soniox\"} 切换模型重试。GET /api/v1/providers：查询所有语音模型就绪状态。
",
- ))
+ doc = {
+ "service": "meeting-asr",
+ "endpoints": [
+ "GET /health, /readyz",
+ "GET /api/v1/providers",
+ "GET /api/v1/settings",
+ "POST /api/v1/settings",
+ "POST /api/v1/jobs (headers: X-Filename, X-Title, X-Context, X-ASR-Provider, X-ASR-Model)",
+ "GET /api/v1/jobs?status=&provider=&q=&limit=30&offset=0",
+ "GET /api/v1/jobs/{job_id}",
+ "DELETE /api/v1/jobs/{job_id}",
+ "GET /api/v1/jobs/{job_id}/artifacts/{transcript|draft|result}",
+ "GET /api/v1/jobs/{job_id}/reviews",
+ "POST /api/v1/jobs/{job_id}/reviews/{question_id}",
+ "POST /api/v1/jobs/{job_id}/retry (json: {\"provider\": \"soniox\", \"model\": \"\"})",
+ "POST /api/v1/jobs/{job_id}/rerefine",
+ ],
+ }
+ return self.send_data(shell("API 文档", f'
API 接口说明
{html.escape(json.dumps(doc, ensure_ascii=False, indent=2))}'))
if path == "/ui/jobs":
- q = urllib.parse.parse_qs(parsed.query)
- st = q.get("status", [""])[0]
- return self.json({"jobs": [public(x) for x in db.list_jobs(50, 0, st)]})
+ status_flt = q.get("status", [""])[0]
+ prov_flt = q.get("provider", [""])[0]
+ q_flt = q.get("q", [""])[0]
+ return self.json({
+ "jobs": [
+ public(x)
+ for x in db.list_jobs(60, 0, status=status_flt, q=q_flt, provider=prov_flt)
+ ]
+ })
m = re.fullmatch(r"/jobs/([0-9a-f]{24})/", path)
if m:
job = db.get_job(m.group(1))
- return self.send_data(job_page(job)) if job else self.send_data(b"Not found", 404, "text/plain")
- m = re.fullmatch(r"/jobs/([0-9a-f]{24})/audio", path)
- if m:
- return self.stream_audio(db.get_job(m.group(1)))
+ return self.send_data(job_page(job, q.get("msg", [""])[0])) if job else self.send_data(b"Not found", 404, "text/plain")
m = re.fullmatch(r"/jobs/([0-9a-f]{24})/review/", path)
if m:
job = db.get_job(m.group(1))
- return self.send_data(review_page(job)) if job else self.send_data(b"Not found", 404, "text/plain")
+ return self.send_data(review_page(job, q.get("msg", [""])[0])) if job else self.send_data(b"Not found", 404, "text/plain")
+ m = re.fullmatch(r"/jobs/([0-9a-f]{24})/audio", path)
+ if m:
+ return self.stream_audio(db.get_job(m.group(1)))
m = re.fullmatch(r"/jobs/([0-9a-f]{24})/artifact/(transcript|draft|result)", path)
if m:
- return self.artifact(db.get_job(m.group(1)), m.group(2))
+ return self.artifact(db.get_job(m.group(1)), m.group(2), False)
self.send_data(b"Not found", 404, "text/plain")
+ def do_DELETE(self) -> None:
+ path = urllib.parse.urlsplit(self.path).path
+ m = re.fullmatch(r"/api/v1/jobs/([0-9a-f]{24})", path)
+ if m:
+ if not self.need_auth():
+ return
+ ok = delete_job_and_artifacts(m.group(1), delete_files=True, delete_result=False)
+ return self.json({"ok": ok}, 200 if ok else 404)
+ self.json({"error": "not found"}, 404)
+
def do_POST(self) -> None:
path = urllib.parse.urlsplit(self.path).path
if path == "/login":
- length = min(int(self.headers.get("Content-Length", "0")), 4096)
- form = urllib.parse.parse_qs(self.rfile.read(length).decode("utf-8", errors="ignore"))
+ form = self.read_form(4096)
pw = form.get("password", [""])[0]
if WEB_PASSWORD and hmac.compare_digest(pw, WEB_PASSWORD):
self.send_response(303)
+ self.send_header("Location", "/")
self.send_header(
"Set-Cookie",
f"asr_session={_session_token()}; Path=/; HttpOnly; SameSite=Lax; Max-Age=2592000",
)
- self.send_header("Location", "/")
self.end_headers()
return
- return self.send_data(login_page("口令不正确"), 401)
+ return self.send_data(login_page("口令错误，请重试"), 401)
+
if path == "/ui/upload":
return self.upload("web", False)
if path == "/api/v1/jobs":
return self.upload("agent", True)
+ if path == "/api/v1/settings":
+ if not self.need_auth():
+ return
+ length = min(int(self.headers.get("Content-Length", "0")), 32768)
+ body = json.loads(self.rfile.read(length).decode("utf-8") or "{}")
+ db.save_settings(body)
+ return self.json({"ok": True})
+
m = re.fullmatch(r"/api/v1/jobs/([0-9a-f]{24})/reviews/(\d+)", path)
if m:
if not self.need_auth():
return
job = db.get_job(m.group(1))
- length = min(int(self.headers.get("Content-Length", "0")), 4096)
- try:
- answer = str(json.loads(self.rfile.read(length)).get("answer") or "").strip()
- except (ValueError, AttributeError):
- answer = ""
qid = int(m.group(2))
- if not job or qid not in {x["id"] for x in pending(job)} or not answer:
- return self.json({"error": "invalid review answer"}, 400)
- return self.json(review.answer(qid, answer[:120]))
+ if not job or qid not in {x["id"] for x in pending(job)}:
+ return self.json({"error": "not found"}, 404)
+ length = min(int(self.headers.get("Content-Length", "0")), 4096)
+ body = json.loads(self.rfile.read(length).decode("utf-8") or "{}")
+ ans = str(body.get("answer", "")).strip()
+ if not ans:
+ return self.json({"error": "answer required"}, 400)
+ return self.json(review.answer(qid, ans[:200]))
+
+ m = re.fullmatch(r"/(?:api/v1/)?jobs/([0-9a-f]{24})/rerefine", path)
+ if m:
+ api = path.startswith("/api/")
+ if api and not self.need_auth():
+ return
+ if not api and not self.need_web_auth():
+ return
+ job = db.get_job(m.group(1))
+ if not job:
+ return self.json({"error": "not found"}, 404)
+ ok = queue_rerefine(job)
+ if api:
+ return self.json({"ok": ok}, 202 if ok else 409)
+ return self.redirect(f"/jobs/{job['id']}/?msg=" + urllib.parse.quote("已加入重新精修队列"))
m = re.fullmatch(r"/(?:api/v1/)?jobs/([0-9a-f]{24})/retry", path)
if m:
@@ -844,7 +1517,7 @@ class Handler(BaseHTTPRequestHandler):
return self.json({"error": "cannot retry"}, 409)
length = min(int(self.headers.get("Content-Length", "0")), 4096)
raw_body = self.rfile.read(length).decode("utf-8", errors="ignore") if length > 0 else ""
- new_prov = job.get("asr_provider") or DEFAULT_PROVIDER
+ new_prov = job.get("asr_provider") or CFG.asr_provider
new_model = job.get("asr_model") or ""
if raw_body:
if api and raw_body.strip().startswith("{"):
@@ -865,7 +1538,6 @@ class Handler(BaseHTTPRequestHandler):
dest = INBOX / job["stored_name"]
if source.resolve() != dest.resolve():
shutil.copyfile(source, dest) if source.parent == PROCESSED else source.replace(dest)
- # Touch mtime slightly in the past so worker picks it up without extra wait
old_ts = time.time() - 60
os.utime(dest, (old_ts, old_ts))
db.update_job(
@@ -874,63 +1546,297 @@ class Handler(BaseHTTPRequestHandler):
)
if api:
return self.json({"ok": True, "asr_provider": new_prov, "asr_model": new_model}, 202)
- self.send_response(303)
- self.send_header("Location", f"/jobs/{job['id']}/")
- self.end_headers()
- return
+ return self.redirect(f"/jobs/{job['id']}/")
if not self.need_web_auth():
return
+ # ---- Task deletion & metadata editing ----
+ if path == "/jobs/batch-delete":
+ form = self.read_form(65536)
+ del_files = form.get("delete_files", ["1"])[0] == "1"
+ if form.get("cleanup_failed"):
+ failed_jobs = db.list_jobs(200, 0, status="failed")
+ for fj in failed_jobs:
+ delete_job_and_artifacts(fj["id"], delete_files=del_files, delete_result=False)
+ return self.redirect("/?msg=" + urllib.parse.quote(f"已清理 {len(failed_jobs)} 个失败任务"))
+ ids = form.get("job_id", [])
+ n_del = 0
+ for jid in ids:
+ if delete_job_and_artifacts(jid, delete_files=del_files, delete_result=False):
+ n_del += 1
+ return self.redirect("/?msg=" + urllib.parse.quote(f"已删除 {n_del} 个任务"))
+
+ m = re.fullmatch(r"/jobs/([0-9a-f]{24})/delete", path)
+ if m:
+ form = self.read_form(4096)
+ del_files = form.get("delete_files", ["0"])[0] == "1"
+ del_res = form.get("delete_result", ["0"])[0] == "1"
+ delete_job_and_artifacts(m.group(1), delete_files=del_files, delete_result=del_res)
+ return self.redirect("/?msg=" + urllib.parse.quote("任务已删除"))
+
+ m = re.fullmatch(r"/jobs/([0-9a-f]{24})/meta", path)
+ if m:
+ job = db.get_job(m.group(1))
+ if not job:
+ return self.send_data(b"Not found", 404, "text/plain")
+ form = self.read_form(32768)
+ new_title = safe(form.get("title", [""])[0], 80)
+ new_ctx = safe(form.get("context", [""])[0], 2000)
+ new_prov = providers.normalize_provider_name(form.get("provider", [CFG.asr_provider])[0])
+ new_model = safe(form.get("model", [""])[0], 80)
+ db.update_job_meta(
+ job["id"], title=new_title, context=new_ctx,
+ asr_provider=new_prov, asr_model=new_model,
+ )
+ action = form.get("next_action", ["save"])[0]
+ updated_job = db.get_job(job["id"]) or job
+ if action == "rerefine":
+ queue_rerefine(updated_job)
+ return self.redirect(f"/jobs/{job['id']}/?msg=" + urllib.parse.quote("已保存并排队重新生成草稿"))
+ if action == "retry":
+ source = find_audio_file(updated_job)
+ if source:
+ dest = INBOX / updated_job["stored_name"]
+ if source.resolve() != dest.resolve():
+ shutil.copyfile(source, dest) if source.parent == PROCESSED else source.replace(dest)
+ old_ts = time.time() - 60
+ os.utime(dest, (old_ts, old_ts))
+ db.update_job(
+ job["id"], "queued", f"重新排队转写 (ASR: {new_prov})",
+ error_code="", asr_provider=new_prov, asr_model=new_model,
+ )
+ return self.redirect(f"/jobs/{job['id']}/?msg=" + urllib.parse.quote("已保存并重新排队转写"))
+ return self.redirect(f"/jobs/{job['id']}/?msg=" + urllib.parse.quote("任务信息已更新"))
+
+ m = re.fullmatch(r"/jobs/([0-9a-f]{24})/revise", path)
+ if m:
+ job = db.get_job(m.group(1))
+ if not job:
+ return self.send_data(b"Not found", 404, "text/plain")
+ queue_revise_draft(job)
+ return self.redirect(f"/jobs/{job['id']}/?msg=" + urllib.parse.quote("已触发修订与定稿流程"))
+
+ # ---- Multi-recording review submission ----
if path == "/review/" or re.fullmatch(r"/jobs/([0-9a-f]{24})/review/", path):
m_job = re.fullmatch(r"/jobs/([0-9a-f]{24})/review/", path)
job = db.get_job(m_job.group(1)) if m_job else None
- length = min(int(self.headers.get("Content-Length", "0")), 4096)
- form = urllib.parse.parse_qs(self.rfile.read(length).decode("utf-8", errors="ignore"))
- qid = int(form.get("id", ["0"])[0])
- answer = form.get("custom", [""])[0].strip() or form.get("answer", [""])[0].strip()
+ form = self.read_form(65536)
allowed_ids = {x["id"] for x in pending(job)}
- if (m_job and not job) or qid not in allowed_ids or not answer:
- return self.send_data(b"Invalid answer", 400, "text/plain")
- review.answer(qid, answer[:120])
- self.send_response(303)
- self.send_header("Location", path)
- self.end_headers()
- return
+ answered_count = 0
+
+ # Case 1: Single preset button clicked (`single_submit` = "qid::answer")
+ if form.get("single_submit"):
+ raw_val = form["single_submit"][0]
+ if "::" in raw_val:
+ qid_str, ans_val = raw_val.split("::", 1)
+ if qid_str.isdigit() and int(qid_str) in allowed_ids and ans_val.strip():
+ review.answer(int(qid_str), ans_val.strip()[:200])
+ answered_count += 1
+ # Case 2: Single custom button clicked (`single_custom` = "qid")
+ elif form.get("single_custom"):
+ qid_str = form["single_custom"][0]
+ if qid_str.isdigit() and int(qid_str) in allowed_ids:
+ ans_val = (
+ form.get(f"custom_{qid_str}", [""])[0].strip()
+ or form.get(f"preset_{qid_str}", [""])[0].strip()
+ )
+ if ans_val:
+ review.answer(int(qid_str), ans_val[:200])
+ answered_count += 1
+ # Case 3: Skip all questions in the recording group
+ elif form.get("batch_skip_all"):
+ qids = [
+ int(x) for x in form.get("question_ids", [""])[0].split(",")
+ if x.strip().isdigit() and int(x) in allowed_ids
+ ]
+ for qid in qids:
+ review.answer(qid, "无法确认，保留原文")
+ answered_count += 1
+ # Case 4: Batch submit filled questions in the recording group
+ elif form.get("batch_submit"):
+ qids = [
+ int(x) for x in form.get("question_ids", [""])[0].split(",")
+ if x.strip().isdigit() and int(x) in allowed_ids
+ ]
+ for qid in qids:
+ ans_val = (
+ form.get(f"custom_{qid}", [""])[0].strip()
+ or form.get(f"preset_{qid}", [""])[0].strip()
+ )
+ if ans_val:
+ review.answer(qid, ans_val[:200])
+ answered_count += 1
+ # Legacy fallback (`id` + `answer`/`custom`)
+ elif form.get("id"):
+ qid = int(form.get("id", ["0"])[0] or 0)
+ ans_val = form.get("custom", [""])[0].strip() or form.get("answer", [""])[0].strip()
+ if qid in allowed_ids and ans_val:
+ review.answer(qid, ans_val[:200])
+ answered_count += 1
+
+ return self.redirect(f"{path}?msg=" + urllib.parse.quote(f"已提交 {answered_count} 项确认"))
+
+ if path == "/review/update-answer":
+ form = self.read_form(8192)
+ qid = int(form.get("id", ["0"])[0] or 0)
+ if qid > 0:
+ if form.get("reopen"):
+ review.reopen_question(qid)
+ return self.redirect("/review/?msg=" + urllib.parse.quote(f"问题 #{qid} 已撤回至待确认队列"))
+ new_ans = safe(form.get("answer", [""])[0], 200)
+ if new_ans:
+ review.answer(qid, new_ans, allow_update=True)
+ return self.redirect("/review/?msg=" + urllib.parse.quote(f"问题 #{qid} 回答已更新"))
+ return self.redirect("/review/")
m_edit = re.fullmatch(r"/jobs/([0-9a-f]{24})/edit", path)
if m_edit:
job = db.get_job(m_edit.group(1))
if not job:
return self.send_data(b"Not found", 404, "text/plain")
- length = min(int(self.headers.get("Content-Length", "0")), 2 * 1024 * 1024)
- form = urllib.parse.parse_qs(self.rfile.read(length).decode("utf-8", errors="ignore"))
+ form = self.read_form(2 * 1024 * 1024)
target = form.get("target", [""])[0]
content = form.get("content", [""])[0]
if target in ("draft", "result") and job.get(target) and content.strip():
tpath = Path(str(job[target]))
vault.write_draft_file(tpath, content)
- self.send_response(303)
- self.send_header("Location", f"/jobs/{job['id']}/")
- self.end_headers()
- return
+ return self.redirect(f"/jobs/{job['id']}/?msg=" + urllib.parse.quote("Markdown 修改已保存"))
+ # ---- Lexicon CRUD endpoints ----
if path == "/lexicon/learn":
- length = min(int(self.headers.get("Content-Length", "0")), 4096)
- form = urllib.parse.parse_qs(self.rfile.read(length).decode("utf-8", errors="ignore"))
+ form = self.read_form(8192)
alias_val = safe(form.get("alias", [""])[0], 40)
canon_val = safe(form.get("canonical", [""])[0], 40)
+ kind_val = safe(form.get("kind", [""])[0], 20)
note_val = safe(form.get("note", [""])[0], 120)
+ tab = safe(form.get("tab", ["aliases"])[0], 20)
if alias_val and canon_val:
- lexicon.learn_alias(alias_val, canon_val, note=note_val)
+ lexicon.learn_alias(alias_val, canon_val, kind=kind_val, origin="manual", note=note_val)
lexicon.learn_correction(alias_val, canon_val, note=note_val)
- return self.send_data(lexicon_page(f"已添加映射：{alias_val} → {canon_val}"))
- return self.send_data(lexicon_page("请填写完整的别名与规范名"), 400)
+ return self.redirect(f"/lexicon?tab={tab}&msg=" + urllib.parse.quote(f"已添加映射：{alias_val} → {canon_val}"))
+ return self.redirect(f"/lexicon?tab={tab}&msg=" + urllib.parse.quote("请填写完整的词条映射"))
+
+ if path == "/lexicon/alias/update":
+ form = self.read_form(8192)
+ old_a = safe(form.get("old_alias", [""])[0], 40)
+ old_c = safe(form.get("old_canonical", [""])[0], 40)
+ new_a = safe(form.get("alias", [""])[0], 40)
+ new_c = safe(form.get("canonical", [""])[0], 40)
+ kind = safe(form.get("kind", ["人名"])[0], 20)
+ conf = 1 if form.get("confirmed") else 0
+ note = safe(form.get("note", [""])[0], 120)
+ if new_a and new_c:
+ lexicon.update_alias(old_a or new_a, old_c or new_c, new_a, new_c, kind=kind, confirmed=conf, note=note)
+ return self.redirect("/lexicon?tab=aliases&msg=" + urllib.parse.quote(f"已更新别名：{new_a} → {new_c}"))
+
+ if path == "/lexicon/alias/delete":
+ form = self.read_form(8192)
+ old_a = safe(form.get("old_alias", form.get("alias", [""]))[0], 40)
+ old_c = safe(form.get("old_canonical", form.get("canonical", [""]))[0], 40)
+ lexicon.delete_alias(old_a, old_c)
+ return self.redirect("/lexicon?tab=aliases&msg=" + urllib.parse.quote(f"已删除别名：{old_a}"))
+
+ if path == "/lexicon/correction/update":
+ form = self.read_form(8192)
+ old_s = safe(form.get("old_surface", [""])[0], 40)
+ old_c = safe(form.get("old_canonical", [""])[0], 40)
+ new_s = safe(form.get("surface", [""])[0], 40)
+ new_c = safe(form.get("canonical", [""])[0], 40)
+ conf = 1 if form.get("confirmed") else 0
+ note = safe(form.get("note", [""])[0], 120)
+ if new_s and new_c:
+ lexicon.update_correction(old_s or new_s, old_c or new_c, new_s, new_c, confirmed=conf, note=note)
+ return self.redirect("/lexicon?tab=corrections&msg=" + urllib.parse.quote(f"已更新纠错：{new_s} → {new_c}"))
+
+ if path == "/lexicon/correction/delete":
+ form = self.read_form(8192)
+ old_s = safe(form.get("old_surface", form.get("surface", [""]))[0], 40)
+ old_c = safe(form.get("old_canonical", form.get("canonical", [""]))[0], 40)
+ lexicon.delete_correction(old_s, old_c)
+ return self.redirect("/lexicon?tab=corrections&msg=" + urllib.parse.quote(f"已删除纠错：{old_s}"))
+
+ if path == "/lexicon/entity/update":
+ form = self.read_form(8192)
+ old_c = safe(form.get("old_canonical", [""])[0], 60)
+ new_c = safe(form.get("canonical", [""])[0], 60)
+ kind = safe(form.get("kind", ["人名"])[0], 20)
+ comp = safe(form.get("company", [""])[0], 80)
+ role = safe(form.get("role", [""])[0], 80)
+ rel = safe(form.get("related", [""])[0], 160)
+ if new_c:
+ if old_c:
+ lexicon.update_entity(old_c, new_c, kind, company=comp, role=role, related=rel)
+ else:
+ lexicon.upsert_entity(new_c, kind, company=comp, role=role, related=rel)
+ return self.redirect("/lexicon?tab=entities&msg=" + urllib.parse.quote(f"已保存实体：{new_c}"))
+
+ if path == "/lexicon/entity/delete":
+ form = self.read_form(8192)
+ old_c = safe(form.get("old_canonical", form.get("canonical", [""]))[0], 60)
+ lexicon.delete_entity(old_c)
+ return self.redirect("/lexicon?tab=entities&msg=" + urllib.parse.quote(f"已删除实体：{old_c}"))
+
+ if path == "/lexicon/relation/update":
+ form = self.read_form(8192)
+ old_s = safe(form.get("old_subject", [""])[0], 60)
+ old_p = safe(form.get("old_predicate", [""])[0], 40)
+ old_o = safe(form.get("old_object", [""])[0], 60)
+ old_src = safe(form.get("old_source", ["manual"])[0], 120)
+ subj = safe(form.get("subject", [""])[0], 60)
+ pred = safe(form.get("predicate", [""])[0], 40)
+ obj = safe(form.get("object", [""])[0], 60)
+ try:
+ conf = float(form.get("confidence", ["0.85"])[0])
+ except ValueError:
+ conf = 0.85
+ act = 1 if form.get("active") else 0
+ if subj and pred and obj:
+ if old_s and old_p and old_o:
+ lexicon.update_relation(old_s, old_p, old_o, old_src, subj, pred, obj, confidence=conf, active=act)
+ else:
+ lexicon.upsert_relation(subj, pred, obj, confidence=conf, source="manual")
+ return self.redirect("/lexicon?tab=relations&msg=" + urllib.parse.quote(f"已保存关系：{subj} {pred} {obj}"))
+
+ if path == "/lexicon/relation/delete":
+ form = self.read_form(8192)
+ old_s = safe(form.get("old_subject", form.get("subject", [""]))[0], 60)
+ old_p = safe(form.get("old_predicate", form.get("predicate", [""]))[0], 40)
+ old_o = safe(form.get("old_object", form.get("object", [""]))[0], 60)
+ old_src = safe(form.get("old_source", ["manual"])[0], 120)
+ lexicon.delete_relation(old_s, old_p, old_o, old_src)
+ return self.redirect("/lexicon?tab=relations&msg=" + urllib.parse.quote(f"已删除关系：{old_s} {old_p} {old_o}"))
if path == "/lexicon/sync":
l_res = lexicon.sync_from_vault(force=True)
g_res = graph.sync(force=True)
- return self.send_data(lexicon_page(f"同步完成：词库 {l_res}，图谱 {g_res}"))
+ return self.redirect("/lexicon?msg=" + urllib.parse.quote(f"同步完成：词库 {l_res}，图谱 {g_res}"))
+
+ # ---- SQLite Settings Save ----
+ if path == "/settings":
+ form = self.read_form(32768)
+ updates: dict[str, str] = {}
+ text_keys = (
+ "litellm_base_url", "clean_model", "keyword_model", "draft_model",
+ "asr_provider", "diarize_url", "voiceprint_enroll_url",
+ "soniox_api_base", "soniox_model", "gemini_asr_model", "openai_asr_model",
+ "grok_api_base", "grok_asr_model", "hindsight_api", "hindsight_bank",
+ )
+ for k in text_keys:
+ if k in form:
+ updates[k] = safe(form[k][0], 200)
+ if "asr_provider" in updates:
+ updates["asr_provider"] = providers.normalize_provider_name(updates["asr_provider"])
+ for sk in ("litellm_api_key", "soniox_api_key", "grok_api_key"):
+ raw_k = form.get(sk, [""])[0].strip()
+ if raw_k == "CLEAR":
+ updates[sk] = ""
+ elif raw_k:
+ updates[sk] = raw_k
+ for bk in ("use_hindsight", "use_termbank", "git_sync"):
+ updates[bk] = "1" if form.get(bk) else "0"
+ db.save_settings(updates)
+ return self.redirect("/settings?msg=" + urllib.parse.quote("配置已保存至 SQLite 并立即生效"))
self.send_data(b"Not found", 404, "text/plain")
diff --git a/servers/tools-pve/asr-pipeline/asrservice/worker.py b/servers/tools-pve/asr-pipeline/asrservice/worker.py
index 94315e8..167f30d 100644
--- a/servers/tools-pve/asr-pipeline/asrservice/worker.py
+++ b/servers/tools-pve/asr-pipeline/asrservice/worker.py
@@ -4,6 +4,7 @@ import fcntl
import hashlib
import json
import os
+import re
import shutil
import sqlite3
import time
@@ -11,9 +12,10 @@ import uuid
from pathlib import Path
from asrpipe import graph, lexicon, providers, refine, review, revise, vault
+from asrpipe.config import CFG
from . import db
from .config import (
- DATA, DEFAULT_PROVIDER, DRAFTS, FAILED, INBOX, LOGS, MAX_ATTEMPTS,
+ DATA, DRAFTS, FAILED, INBOX, LOGS, MAX_ATTEMPTS,
POLL_SECONDS, PROCESSED, PROCESSING, PUBLIC_URL, REVISION_QUEUE,
STABLE_SECONDS, STATE, SUPPORTED, TRANSCRIPTS, ensure_dirs,
)
@@ -50,7 +52,7 @@ def transcribe(
) -> tuple[Path, providers.TranscribeResult]:
res = providers.transcribe_audio(
audio,
- provider=provider or DEFAULT_PROVIDER,
+ provider=provider or CFG.asr_provider,
model=model,
title=title,
user_context=user_context,
@@ -71,7 +73,7 @@ def transcribe(
def process_audio(source: Path, job: dict) -> None:
job_id = job["id"]
attempts = int(job.get("attempts") or 0) + 1
- prov = providers.normalize_provider_name(job.get("asr_provider") or DEFAULT_PROVIDER)
+ prov = providers.normalize_provider_name(job.get("asr_provider") or CFG.asr_provider)
model = str(job.get("asr_model") or "")
digest = sha256(source)
prov_label = providers.PROVIDERS.get(prov, {}).get("label", prov)
@@ -120,6 +122,47 @@ def process_audio(source: Path, job: dict) -> None:
f"{PUBLIC_URL}/jobs/{job_id}/review/")
+def rerefine_job(job: dict) -> None:
+ """Re-run LLM refinement on an existing raw transcript without re-running ASR."""
+ job_id = job["id"]
+ transcript = Path(str(job.get("transcript") or ""))
+ if not transcript.is_file():
+ raise FileNotFoundError(f"transcript file missing for job {job_id}: {transcript}")
+ raw = transcript.read_text(encoding="utf-8", errors="ignore")
+ intake = {
+ "job_id": job_id,
+ "title": job.get("title", ""),
+ "context": job.get("context", ""),
+ "source": job.get("source", ""),
+ "asr_provider": job.get("asr_provider") or CFG.asr_provider,
+ "asr_model": job.get("asr_model") or "",
+ }
+ intake_line = f""
+ if re.match(r"^", raw):
+ raw = re.sub(r"^", intake_line, raw, count=1)
+ else:
+ raw = intake_line + "\n" + raw
+ transcript.write_text(raw, encoding="utf-8")
+
+ db.update_job(job_id, "refining", "正在基于现有转写重新生成精修草稿")
+ review.delete_for_job(
+ transcript_path=str(transcript),
+ draft_path=str(job.get("draft") or ""),
+ job_id=job_id,
+ )
+ result = refine.refine(
+ raw, date=time.strftime("%Y-%m-%d"),
+ transcript_path=str(transcript), queue_review=True,
+ )
+ draft = DRAFTS / f"{job_id}.md"
+ vault.write_draft_file(draft, result.draft)
+ questions = review.enqueue_draft(str(transcript), draft)
+ db.update_job(
+ job_id, "review", f"整理稿已重新生成，{questions} 个问题待确认",
+ transcript=str(transcript), draft=str(draft),
+ )
+
+
def claim(path: Path) -> tuple[Path, dict]:
job = db.find_by_stored(path.name)
if not job:
@@ -127,7 +170,7 @@ def claim(path: Path) -> tuple[Path, dict]:
job = db.create_job(
job_id, path.name, path.name, title=path.stem,
size=path.stat().st_size, source="ssh",
- asr_provider=DEFAULT_PROVIDER,
+ asr_provider=CFG.asr_provider,
)
target = PROCESSING / path.name
if target.exists():
@@ -164,8 +207,15 @@ def process_revisions() -> None:
for marker in sorted(REVISION_QUEUE.glob("*.json")):
try:
payload = json.loads(marker.read_text(encoding="utf-8"))
- draft = Path(payload["draft"])
+ action = str(payload.get("action") or "revise")
job_id = str(payload.get("job_id") or "")
+ if action == "rerefine":
+ job = db.get_job(job_id)
+ if job:
+ rerefine_job(job)
+ marker.unlink(missing_ok=True)
+ continue
+ draft = Path(payload["draft"])
db.update_job(job_id, "publishing", "正在应用人工确认")
revise.revise(draft)
current = db.get_job(job_id) or {}
@@ -181,6 +231,14 @@ def process_revisions() -> None:
marker.unlink(missing_ok=True)
except Exception as exc:
log(f"revision marker={marker.name} failed type={type(exc).__name__} err={exc}")
+ try:
+ payload = json.loads(marker.read_text(encoding="utf-8"))
+ jid = str(payload.get("job_id") or "")
+ if jid:
+ db.update_job(jid, "failed", f"精修/修订失败：{exc}", error_code=type(exc).__name__)
+ except Exception:
+ pass
+ marker.unlink(missing_ok=True)
def recover() -> None:
diff --git a/servers/tools-pve/asr-pipeline/tests/test_service.py b/servers/tools-pve/asr-pipeline/tests/test_service.py
index 27c44b5..569b3cc 100644
--- a/servers/tools-pve/asr-pipeline/tests/test_service.py
+++ b/servers/tools-pve/asr-pipeline/tests/test_service.py
@@ -5,6 +5,7 @@ import os
import tempfile
import threading
import unittest
+import urllib.parse
import urllib.request
from http.server import ThreadingHTTPServer
from pathlib import Path
@@ -20,6 +21,7 @@ os.environ["ASR_NOTIFY"] = "0"
os.environ["ASR_GIT_SYNC"] = "0"
from asrpipe import lexicon, providers, review, segment # noqa: E402
+from asrpipe.config import CFG # noqa: E402
from asrservice import config as svc_cfg, db as svc_db, web as svc_web # noqa: E402
@@ -33,6 +35,28 @@ class ProviderAndServiceTests(unittest.TestCase):
def tearDown(self):
self.tmp.cleanup()
+ def test_sqlite_settings_override_config_dynamically(self):
+ svc_db.save_settings({
+ "asr_provider": "soniox",
+ "litellm_base_url": "https://api.opfo.xyz/v1",
+ "litellm_api_key": "sk-sqlite-dynamic-key",
+ "clean_model": "aistudio/gemini-flash-latest",
+ "draft_model": "openai/gpt-sol-latest",
+ "soniox_api_key": "soniox-db-secret",
+ "use_hindsight": "0",
+ })
+ self.assertEqual(CFG.asr_provider, "soniox")
+ self.assertEqual(CFG.litellm_base_url, "https://api.opfo.xyz/v1")
+ self.assertEqual(CFG.endpoint, "https://api.opfo.xyz/v1/chat/completions")
+ self.assertEqual(CFG.transcriptions_endpoint, "https://api.opfo.xyz/v1/audio/transcriptions")
+ self.assertEqual(CFG.api_key(), "sk-sqlite-dynamic-key")
+ self.assertEqual(CFG.clean_model, "aistudio/gemini-flash-latest")
+ self.assertEqual(CFG.draft_model, "openai/gpt-sol-latest")
+ self.assertEqual(CFG.soniox_api_key, "soniox-db-secret")
+ self.assertFalse(CFG.use_hindsight)
+ # Restore default for subsequent tests
+ svc_db.save_settings({"asr_provider": "qwen3cam", "use_hindsight": "1"})
+
def test_soniox_token_diarization_and_segment_parse(self):
payload = {
"tokens": [
@@ -135,20 +159,76 @@ class ProviderAndServiceTests(unittest.TestCase):
updated = draft.read_text(encoding="utf-8")
self.assertIn("speaker_1: 张三", updated)
- def test_db_and_web_endpoints(self):
- job_id = "0123456789abcdef01234567"
- job = svc_db.create_job(
- job_id=job_id,
- original_name="meeting.m4a",
- stored_name=f"20261102-{job_id}.m4a",
- title="架构周会",
- context="验证 Web API",
+ def test_lexicon_crud_operations(self):
+ # Entity CRUD
+ lexicon.upsert_entity("测试生物", "公司", company="测试集团", role="子公司", related="李四")
+ ents = lexicon.list_entities(q="测试生物")
+ self.assertEqual(len(ents), 1)
+ self.assertEqual(ents[0]["company"], "测试集团")
+
+ lexicon.update_entity("测试生物", "测试生物科技", "公司", company="新集团", role="总部", related="李四,王五")
+ ents2 = lexicon.list_entities(q="测试生物科技")
+ self.assertEqual(len(ents2), 1)
+ self.assertEqual(ents2[0]["company"], "新集团")
+ self.assertTrue(lexicon.delete_entity("测试生物科技"))
+ self.assertEqual(len(lexicon.list_entities(q="测试生物科技")), 0)
+
+ # Alias & Correction CRUD
+ lexicon.learn_alias("老测试", "测试人", kind="人名", origin="manual", note="初始")
+ lexicon.update_alias("老测试", "测试人", "小测试", "测试人", kind="人名", confirmed=1, note="已改")
+ aliases = lexicon.list_aliases(q="小测试")
+ self.assertEqual(len(aliases), 1)
+ self.assertEqual(aliases[0]["note"], "已改")
+ self.assertTrue(lexicon.delete_alias("小测试", "测试人"))
+
+ lexicon.learn_correction("误识词", "正词", note="c1")
+ lexicon.update_correction("误识词", "正词", "新误识词", "正词", confirmed=1, note="c2")
+ cors = lexicon.list_corrections(q="新误识词")
+ self.assertEqual(len(cors), 1)
+ self.assertEqual(cors[0]["note"], "c2")
+ self.assertTrue(lexicon.delete_correction("新误识词", "正词"))
+
+ # Relation CRUD
+ lexicon.upsert_relation("张三", "任职于", "洛启生物", confidence=0.8, source="manual")
+ lexicon.update_relation("张三", "任职于", "洛启生物", "manual", "张三", "实控人", "洛启生物", confidence=0.95, active=1)
+ rels = lexicon.list_relations(q="张三")
+ self.assertTrue(any(r["predicate"] == "实控人" for r in rels))
+ self.assertTrue(lexicon.delete_relation("张三", "实控人", "洛启生物", "manual"))
+
+ def test_db_web_endpoints_multi_review_and_job_delete(self):
+ job1_id = "0123456789abcdef01234567"
+ job2_id = "fedcba987654321001234567"
+ t1 = svc_cfg.TRANSCRIPTS / f"{job1_id}.txt"
+ t2 = svc_cfg.TRANSCRIPTS / f"{job2_id}.txt"
+ t1.write_text("【speaker_0】录音一内容\n", encoding="utf-8")
+ t2.write_text("【speaker_0】录音二内容\n", encoding="utf-8")
+
+ svc_db.create_job(
+ job_id=job1_id,
+ original_name="meeting1.m4a",
+ stored_name=f"20261102-{job1_id}.m4a",
+ title="第一场尽调会",
+ context="验证多录音确认",
size=2048,
asr_provider="soniox",
asr_model="stt-async-v5",
)
- self.assertEqual(job["asr_provider"], "soniox")
- self.assertEqual(job["asr_model"], "stt-async-v5")
+ svc_db.update_job(job1_id, "review", "待确认", transcript=str(t1))
+
+ svc_db.create_job(
+ job_id=job2_id,
+ original_name="meeting2.m4a",
+ stored_name=f"20261102-{job2_id}.m4a",
+ title="第二场投决会",
+ context="验证批量操作",
+ size=4096,
+ asr_provider="qwen3cam",
+ )
+ svc_db.update_job(job2_id, "review", "待确认", transcript=str(t2))
+
+ q1 = review.enqueue(str(t1), "第一场问题A？", {"kind": "draft_question", "candidates": ["选项A1", "选项A2"]})
+ q2 = review.enqueue(str(t1), "第一场问题B？", {"kind": "draft_question", "candidates": ["选项B1"]})
+ q3 = review.enqueue(str(t2), "第二场问题C？", {"kind": "draft_question", "candidates": ["选项C1"]})
svc_web.AGENT_TOKEN = "test-agent-token"
server = ThreadingHTTPServer(("127.0.0.1", 0), svc_web.Handler)
@@ -164,6 +244,17 @@ class ProviderAndServiceTests(unittest.TestCase):
with urllib.request.urlopen(req, timeout=5) as resp:
return resp.status, resp.read().decode("utf-8")
+ def post_form(path: str, data: dict[str, str]) -> tuple[int, str]:
+ encoded = urllib.parse.urlencode(data).encode("utf-8")
+ req = urllib.request.Request(
+ f"http://127.0.0.1:{port}{path}",
+ data=encoded,
+ headers={"Content-Type": "application/x-www-form-urlencoded"},
+ method="POST",
+ )
+ with urllib.request.urlopen(req, timeout=5) as resp:
+ return resp.status, resp.read().decode("utf-8")
+
status, body = fetch("/health")
self.assertEqual(status, 200)
self.assertEqual(json.loads(body)["ok"], True)
@@ -173,22 +264,57 @@ class ProviderAndServiceTests(unittest.TestCase):
headers={"Authorization": "Bearer test-agent-token"},
)
self.assertEqual(status, 200)
- prov_data = json.loads(body)
- prov_ids = [p["id"] for p in prov_data["providers"]]
+ prov_ids = [p["id"] for p in json.loads(body)["providers"]]
self.assertEqual(prov_ids, ["qwen3cam", "soniox", "gemini", "openai", "grok"])
- status, body = fetch(f"/jobs/{job_id}/")
+ # Multi-recording review page shows both recordings grouped
+ status, body = fetch("/review/")
self.assertEqual(status, 200)
- self.assertIn("架构周会", body)
- self.assertIn("soniox", body)
+ self.assertIn("第一场尽调会", body)
+ self.assertIn("第二场投决会", body)
+ self.assertIn("第一场问题A？", body)
+ self.assertIn("第二场问题C？", body)
- status, body = fetch("/lexicon")
+ # Batch submit both questions for recording 1
+ status, body = post_form(f"/jobs/{job1_id}/review/", {
+ "question_ids": f"{q1},{q2}",
+ f"preset_{q1}": "选项A1",
+ f"custom_{q2}": "自定义回答B",
+ "batch_submit": "1",
+ })
self.assertEqual(status, 200)
- self.assertIn("词库", body)
+ self.assertEqual(len(svc_web.pending(svc_db.get_job(job1_id))), 0)
+ self.assertEqual(len(svc_web.pending(svc_db.get_job(job2_id))), 1)
- status, body = fetch("/settings")
+ # Edit job metadata
+ status, body = post_form(f"/jobs/{job1_id}/meta", {
+ "title": "第一场尽调会（已改名）",
+ "context": "更新后的背景",
+ "provider": "openai",
+ "model": "openai/gpt-4o-transcribe-diarize",
+ "next_action": "save",
+ })
self.assertEqual(status, 200)
- self.assertIn("LiteLLM", body)
+ self.assertIn("第一场尽调会（已改名）", body)
+
+ # Save settings via Web UI POST
+ status, body = post_form("/settings", {
+ "litellm_base_url": "http://192.168.50.49:4000/v1",
+ "clean_model": "aistudio/gemini-flash-lite-latest",
+ "keyword_model": "aistudio/gemini-flash-lite-latest",
+ "draft_model": "codex/gpt-sol-latest",
+ "asr_provider": "soniox",
+ "use_hindsight": "1",
+ })
+ self.assertEqual(status, 200)
+ self.assertEqual(CFG.asr_provider, "soniox")
+
+ # Delete job 2 and verify its pending review question is also cleaned up
+ status, _ = post_form(f"/jobs/{job2_id}/delete", {"delete_files": "1"})
+ self.assertEqual(status, 200)
+ self.assertIsNone(svc_db.get_job(job2_id))
+ self.assertFalse(t2.exists())
+ self.assertNotIn(q3, [r["id"] for r in review.pending(200)])
finally:
server.shutdown()
server.server_close()