489 lines
22 KiB
Python
489 lines
22 KiB
Python
"""投标产线公共层：DB 上下文、角色规范化、门限参数、LLM 调用、项目/招标信息取数。
|
||
|
||
所有 bid_* capability 模块共用本模块，禁止各自重复实现（dspy/capability 都只调这里）。
|
||
"""
|
||
|
||
import json
|
||
import logging
|
||
|
||
from sqlor.dbpools import DBPools
|
||
from appPublic.uniqueID import getID
|
||
|
||
DBNAME = "pipeline"
|
||
PIPELINE_ID = "bidding_general"
|
||
|
||
logger = logging.getLogger("pipeline.bidding")
|
||
|
||
# ── 章节 / 标书状态 ──
|
||
CH_PENDING = "pending"
|
||
CH_WRITING = "writing"
|
||
CH_WRITTEN = "written"
|
||
CH_REVIEWING = "reviewing"
|
||
CH_APPROVED = "approved"
|
||
CH_REJECTED = "rejected"
|
||
|
||
# ── 招标信息状态（bid_tenders 现仅承载解析抽取的商务要素，无审批流）──
|
||
TD_SUMMARIZED = "summarized"
|
||
|
||
# ── 标书状态 ──
|
||
DOC_DRAFT = "draft"
|
||
DOC_REVIEWING = "reviewing"
|
||
DOC_PASSED = "passed"
|
||
DOC_REJECTED = "rejected"
|
||
DOC_DELIVERED = "delivered"
|
||
|
||
# ── 人类任务类型（阻塞门禁）──
|
||
HT_TENDER_FILE = "tender_file_upload"
|
||
HT_HUMAN_DOCS = "human_docs_request"
|
||
HT_QC_ESCALATION = "qc_escalation"
|
||
HT_DELIVERY_CONFIRM = "bid_delivery_confirm"
|
||
HT_FLOW_CONFIRM = "flow_plan_confirm" # 流程裁剪确认（引擎通用类型，pipeline_flow_plans 机制）
|
||
HT_TEMPLATE_CONFIRM = "tech_template_confirm" # 技术方案模版/骨架确认（纯技术方案流程，2026-09-14 批2）
|
||
|
||
BLOCKING_HT_TYPES = (HT_TENDER_FILE, HT_FLOW_CONFIRM, HT_TEMPLATE_CONFIRM)
|
||
# 2026-09-03 起只保留「等招标文件」为全局阻塞：
|
||
# - HT_HUMAN_DOCS（等人类资质文件）降级为章节级依赖——只阻塞商务章（等资料准备），技术/报价章不受影响；
|
||
# - HT_QC_ESCALATION（QC 轮次用尽）降级为章节级依赖——只阻塞依赖该产出类型的章节，其余章节照常流转。
|
||
# 2026-09-11 增 HT_FLOW_CONFIRM：裁剪计划待用户确认期间全局阻塞（确认后才按计划派发，
|
||
# 防「用户在确认、对账器按旧流程抢跑」）。驳回后的暂停由 bid_flow 查 pipeline_flow_plans 状态兜住。
|
||
# 2026-09-14 增 HT_TEMPLATE_CONFIRM：技术方案模版骨架待用户确认期间全局阻塞（用户明确要
|
||
# 「模版由用户确认后」才开写章节——骨架没确认就编写 = 方向错了全白写）。
|
||
|
||
# ── QC 契合度审核类型（解析产出逐类审核）──
|
||
QC_TYPE_SCORING = "scoring_items" # 评分项 + 得分规则
|
||
QC_TYPE_QUALS = "qualifications" # 所需资质
|
||
QC_TYPE_REQS = "doc_requirements" # 投标文件要求
|
||
QC_TYPE_OUTLINE = "chapter_outline" # 章节骨架
|
||
QC_TYPE_COST = "cost_benefit" # 成本收益分析（2026-09-02 四维度拆分新增）
|
||
QC_TYPE_TECH = "tech_items" # 技术评估项（2026-09-14 纯技术方案流程新增）
|
||
QC_TYPES = (QC_TYPE_SCORING, QC_TYPE_QUALS, QC_TYPE_REQS, QC_TYPE_OUTLINE, QC_TYPE_COST)
|
||
# 技术方案流程专属 QC 类型（不进 QC_TYPES——标准流程的 _qc_pending_types 只遍历 QC_TYPES，
|
||
# 技术方案流程由 bid_flow 的 tech 分支单独遍历 TECH_QC_TYPES，两条流程互不串审）
|
||
TECH_QC_TYPES = (QC_TYPE_TECH,)
|
||
|
||
# QC 审核对象 → 产出物落库表（QC 不通过时清空重做的对象；对账器判存在性也用）
|
||
QC_OUTPUT_TABLE = {
|
||
QC_TYPE_SCORING: "bid_scoring_items",
|
||
QC_TYPE_QUALS: "bid_qualifications",
|
||
QC_TYPE_REQS: "bid_doc_requirements",
|
||
QC_TYPE_OUTLINE: "bid_chapters",
|
||
QC_TYPE_COST: "bid_cost_benefit",
|
||
QC_TYPE_TECH: "bid_tech_items",
|
||
}
|
||
|
||
# ── 流程裁剪（pipeline_flow_plans 机制，2026-09-11）──
|
||
# 裁剪计划阶段 key（bid_ability.BID_FLOW_STAGES 声明）→ 分析维度映射。
|
||
# 对账器/PM 编排据此判定某维度是否执行、被裁维度的 QC 依赖是否视为通过。
|
||
STAGE_ANALYSIS = "analysis_scoring"
|
||
STAGE_QUALS = "analysis_quals"
|
||
STAGE_REQS_OUTLINE = "analysis_reqs_outline"
|
||
STAGE_COST_BENEFIT = "analysis_cost_benefit"
|
||
STAGE_QC = "qc_analysis"
|
||
STAGE_PREP = "prep"
|
||
STAGE_CH_REVIEW = "chapter_review"
|
||
STAGE_WHOLE_SCORE = "whole_score"
|
||
STAGE_DELIVERY = "delivery_confirm"
|
||
|
||
DIM_TO_STAGE = {
|
||
"scoring": STAGE_ANALYSIS,
|
||
"quals": STAGE_QUALS,
|
||
"reqs_outline": STAGE_REQS_OUTLINE,
|
||
"cost_benefit": STAGE_COST_BENEFIT,
|
||
}
|
||
|
||
# ── 纯技术方案流程（bid_tech_proposal，2026-09-14 批2）──
|
||
# 阶段 key（bid_ability.TECH_PROPOSAL_STAGES 声明）→ 与标准流程同名字段但含义不同：
|
||
# 该流程以用户提供的技术需求书为唯一基准，QC/评审全部对标需求书原文，不碰评分项。
|
||
FLOW_KEY_TECH_PROPOSAL = "bid_tech_proposal"
|
||
FLOW_KEY_STANDARD = "bid_standard"
|
||
STAGE_TECH_ANALYSIS = "tech_analysis" # 技术需求解析（六类评估项）
|
||
STAGE_TECH_QC = "tech_qc" # 解析产出 QC（对标需求书原文）
|
||
STAGE_TEMPLATE_CONFIRM = "template_confirm" # 方案模版确定 + 用户确认骨架
|
||
STAGE_TECH_CH_WRITE = "tech_chapter_write" # 按确认骨架分章编写
|
||
STAGE_TECH_CH_QC = "tech_chapter_qc" # 章节 QC 评审（对标需求书覆盖度）
|
||
STAGE_TECH_COMPOSE = "tech_compose" # 合成技术方案书
|
||
STAGE_TECH_DELIVERY = "tech_delivery_confirm" # 交付确认
|
||
|
||
# 六类技术评估项（用户 2026-09-11 定义：功能清单/功能点/硬件配置/技术架构/功能架构/部署架构）
|
||
TECH_CATEGORIES = ("function_list", "function_point", "hardware",
|
||
"tech_arch", "func_arch", "deploy_arch")
|
||
|
||
# 任务未终结状态（判断「是否已有在办任务」用）
|
||
# waiting 计入在办（2026-09-11）：PM 复杂度拆解的子任务带 depends_on 时为 waiting，
|
||
# 不算在办会导致对账器重复派发整维度任务/对半成品提前派 QC（09-04 编排堆积同款事故模式）。
|
||
OPEN_TASK_STATES = ("submitted", "running", "review", "qc_review", "waiting")
|
||
# failed 任务单独处理：角色 agent 执行失败（如机构未配 LLM）→ 对账器不重复造任务，抛人工介入
|
||
|
||
# ── 门限默认值（可用 appbase params 表覆盖）──
|
||
DEFAULT_PARAMS = {
|
||
"bid_chapter_pass_ratio": "0.8", # 章节评审通过门限
|
||
"bid_pass_ratio": "0.85", # 整书评分通过门限
|
||
"bid_max_revise": "3", # 单章节最大重做次数
|
||
"bid_max_round": "3", # 整书最大评分轮次
|
||
"bid_qc_pass_score": "8.5", # 解析产出 QC 契合度通过分（10 分制，高于此分才放行；2026-09-02 用户定 8.5）
|
||
"bid_qc_max_round": "3", # 单类产出 QC 最大审核轮次（超限抛人工）
|
||
"bid_chapter_min_words": "800", # 技术标章节最低字数（低于即评审必退）
|
||
"bid_chapter_min_words_biz": "500", # 商务标章节最低字数
|
||
"bid_write_concurrency": "4", # 章节编写并发上限（单轮最多同时派发的编写任务数）
|
||
"bid_split_chars": "60000", # 分析任务机械拆解阈值：招标文件正文超此字符数，
|
||
# 分析维度自动拆为分段子任务（2026-09-15 用户要求：
|
||
# 大任务必须拆解，不能一个任务跑几十分钟）
|
||
}
|
||
|
||
|
||
def get_db():
|
||
"""取 DBPools（databases 为空时从 config 兜底注入，与引擎其他模块一致）。"""
|
||
db = DBPools()
|
||
if not db.databases:
|
||
from appPublic.jsonConfig import getConfig
|
||
config = getConfig()
|
||
if config and config.databases:
|
||
db.databases = config.databases
|
||
return db, DBNAME
|
||
|
||
|
||
def new_id():
|
||
return getID()
|
||
|
||
|
||
def normalize_role(role):
|
||
"""agent 角色补 agent. 前缀；人角色 {orgtype}.{role} 原样返回。"""
|
||
role = (role or "").strip()
|
||
if not role:
|
||
return ""
|
||
if "." in role:
|
||
return role
|
||
return "agent." + role
|
||
|
||
|
||
def rec_to_dict(rec):
|
||
"""sqlor 行对象 → dict（过滤方法名，避免 DictObject 序列化泄漏内置方法）。"""
|
||
if rec is None:
|
||
return {}
|
||
if isinstance(rec, dict):
|
||
return {k: v for k, v in rec.items() if not callable(v)}
|
||
d = {}
|
||
for k, v in vars(rec).items():
|
||
if k.startswith("_") or callable(v):
|
||
continue
|
||
d[k] = v
|
||
return d
|
||
|
||
|
||
def rows_to_dicts(recs, limit=200):
|
||
return [rec_to_dict(r) for r in (recs or [])[:limit]]
|
||
|
||
|
||
def to_float(v, default=0.0):
|
||
try:
|
||
if v is None or v == "":
|
||
return default
|
||
return float(v)
|
||
except (TypeError, ValueError):
|
||
return default
|
||
|
||
|
||
def to_int(v, default=0):
|
||
try:
|
||
if v is None or v == "":
|
||
return default
|
||
return int(float(v))
|
||
except (TypeError, ValueError):
|
||
return default
|
||
|
||
|
||
def json_loads(s, default=None):
|
||
if not s:
|
||
return default if default is not None else []
|
||
if isinstance(s, (list, dict)):
|
||
return s
|
||
try:
|
||
return json.loads(s)
|
||
except (json.JSONDecodeError, TypeError, ValueError):
|
||
return default if default is not None else []
|
||
|
||
|
||
async def get_param(sor, key, default=""):
|
||
"""读 appbase params 表配置（复用引擎 workspace.get_param，不重复实现）+ 默认兜底。"""
|
||
try:
|
||
from pipeline_service.workspace import get_param as _gp
|
||
v = await _gp(sor, key, "")
|
||
if v not in (None, ""):
|
||
return str(v)
|
||
except Exception:
|
||
pass
|
||
return str(DEFAULT_PARAMS.get(key, default))
|
||
|
||
|
||
async def resolve_project_id(project_id="", **entity_ids):
|
||
"""补齐/校验 project_id：必须是 sd_projects 真实存在的项目。
|
||
|
||
角色工具经引擎分发时默认注入会话当前项目；为空时（无会话上下文）按实体反查，
|
||
避免「项目不明」导致跨项目读写。全部反查失败抛 ValueError。
|
||
|
||
键漂移防护（2026-09-02）：调用方可能把项目「名字」误当 project_id 传入
|
||
（曾致 bid_chapters 26 条记录以名字为键落库，与正确 id 键骨架并存形成双骨架）。
|
||
此处统一校验：传入值先按 id 查；查不到再按 name 反查并归一为真实 id；
|
||
名字命中多个项目则拒绝（歧义），彻底堵住「名字当 id」写库。
|
||
"""
|
||
if project_id:
|
||
db, dbname = get_db()
|
||
async with db.sqlorContext(dbname) as sor:
|
||
recs = await sor.sqlExe(
|
||
"SELECT id FROM sd_projects WHERE id=${p}$ LIMIT 1", {"p": project_id})
|
||
await sor.sqlExe("COMMIT", {})
|
||
if recs:
|
||
return project_id
|
||
# 按名字反查（键漂移容错：误传项目名 → 归一为真实 id）
|
||
recs = await sor.sqlExe(
|
||
"SELECT id FROM sd_projects WHERE name=${p}$", {"p": project_id})
|
||
await sor.sqlExe("COMMIT", {})
|
||
if len(recs) == 1:
|
||
real_id = getattr(recs[0], "id", "")
|
||
logger.warning("resolve_project_id: 项目名「%s」→ 归一为 id %s（键漂移防护）",
|
||
project_id, real_id)
|
||
return real_id
|
||
if len(recs) > 1:
|
||
raise ValueError("项目名「%s」匹配到多个项目，请改用项目 ID 指定" % project_id)
|
||
raise ValueError("项目不存在：%s" % project_id)
|
||
db, dbname = get_db()
|
||
async with db.sqlorContext(dbname) as sor:
|
||
for tbl, col, val in (("bid_chapters", "chapter_id", entity_ids.get("chapter_id")),
|
||
("bid_reviews", "review_id", entity_ids.get("review_id")),
|
||
("bid_documents", "document_id", entity_ids.get("document_id")),
|
||
("bid_tender_files", "file_id", entity_ids.get("file_id"))):
|
||
if not val:
|
||
continue
|
||
recs = await sor.sqlExe(
|
||
"SELECT project_id FROM " + tbl + " WHERE id=${v}$ LIMIT 1", {"v": val})
|
||
await sor.sqlExe("COMMIT", {})
|
||
if recs and getattr(recs[0], "project_id", ""):
|
||
return getattr(recs[0], "project_id", "")
|
||
raise ValueError("缺少 project_id（请指定项目或切换到项目）")
|
||
|
||
|
||
async def get_thresholds(sor):
|
||
"""取门限参数（章节/整书/重做上限/轮次上限 + QC 契合度门限）。"""
|
||
return {
|
||
"chapter_pass_ratio": to_float(await get_param(sor, "bid_chapter_pass_ratio"), 0.8),
|
||
"bid_pass_ratio": to_float(await get_param(sor, "bid_pass_ratio"), 0.85),
|
||
"max_revise": to_int(await get_param(sor, "bid_max_revise"), 3),
|
||
"max_round": to_int(await get_param(sor, "bid_max_round"), 3),
|
||
"qc_pass_score": to_float(await get_param(sor, "bid_qc_pass_score"), 8.5),
|
||
"qc_max_round": to_int(await get_param(sor, "bid_qc_max_round"), 3),
|
||
"chapter_min_words": to_int(await get_param(sor, "bid_chapter_min_words"), 800),
|
||
"chapter_min_words_biz": to_int(await get_param(sor, "bid_chapter_min_words_biz"), 500),
|
||
"write_concurrency": to_int(await get_param(sor, "bid_write_concurrency"), 4),
|
||
"split_chars": to_int(await get_param(sor, "bid_split_chars"), 60000),
|
||
}
|
||
|
||
|
||
async def get_project(sor, project_id):
|
||
"""取项目记录（dict），不存在返回 {}。"""
|
||
if not project_id:
|
||
return {}
|
||
recs = await sor.sqlExe(
|
||
"SELECT id, name, org_id, status, pipeline_id, created_by, default_model "
|
||
"FROM sd_projects WHERE id=${pid}$", {"pid": project_id})
|
||
await sor.sqlExe("COMMIT", {})
|
||
return rec_to_dict(recs[0]) if recs else {}
|
||
|
||
|
||
async def get_tender_by_project(sor, project_id):
|
||
"""取项目关联的招标信息（dict）。"""
|
||
if not project_id:
|
||
return {}
|
||
recs = await sor.sqlExe(
|
||
"SELECT * FROM bid_tenders WHERE project_id=${pid}$ ORDER BY created_at DESC LIMIT 1",
|
||
{"pid": project_id})
|
||
await sor.sqlExe("COMMIT", {})
|
||
return rec_to_dict(recs[0]) if recs else {}
|
||
|
||
|
||
async def create_role_task(sor, project_id, role, title, params=None, owner_id="bid_flow"):
|
||
"""创建角色任务（pipeline_tasks，tenant_id=project_id，pipeline_id='role_task'）。
|
||
|
||
与开发产线共用同一套任务表和 poller —— 投标产线不另建任务机制。
|
||
"""
|
||
tid = new_id()
|
||
params = dict(params or {})
|
||
# 豁免声明（2026-09-03）：投标产线所有角色任务自带质量门禁
|
||
# （解析产出契合度审核 / 章节评审打分），交付后不走引擎通用 QC/PM 门禁。
|
||
params.setdefault("skip_generic_qc", True)
|
||
await sor.C("pipeline_tasks", {
|
||
"id": tid,
|
||
"tenant_id": project_id,
|
||
"pipeline_id": "role_task",
|
||
"owner_id": owner_id,
|
||
"title": (title or "")[:250],
|
||
"params": json.dumps(params, ensure_ascii=False),
|
||
"role": normalize_role(role),
|
||
"state": "submitted",
|
||
"claimed_by": None,
|
||
})
|
||
logger.info("bid create_role_task role=%s task=%s project=%s", role, tid, project_id)
|
||
return tid
|
||
|
||
|
||
async def count_open_tasks(sor, project_id, role=None, chapter_id=None):
|
||
"""统计项目下未终结任务数（可按角色/章节过滤）。用于「已有在办任务就不重复派」。"""
|
||
states = "','".join(OPEN_TASK_STATES)
|
||
sql = ("SELECT id, params FROM pipeline_tasks WHERE tenant_id=${pid}$ "
|
||
"AND pipeline_id='role_task' AND state IN ('" + states + "')")
|
||
p = {"pid": project_id}
|
||
if role:
|
||
sql += " AND role=${role}$"
|
||
p["role"] = normalize_role(role)
|
||
recs = await sor.sqlExe(sql, p)
|
||
await sor.sqlExe("COMMIT", {})
|
||
if chapter_id is None:
|
||
return len(recs or [])
|
||
n = 0
|
||
for r in (recs or []):
|
||
prm = json_loads(getattr(r, "params", "") or "{}", {})
|
||
if isinstance(prm, dict) and prm.get("chapter_id") == chapter_id:
|
||
n += 1
|
||
return n
|
||
|
||
|
||
async def has_done_task(sor, project_id, role):
|
||
"""项目下该角色是否已有验收通过（approved/completed）的任务。"""
|
||
recs = await sor.sqlExe(
|
||
"SELECT id FROM pipeline_tasks WHERE tenant_id=${pid}$ AND pipeline_id='role_task' "
|
||
"AND role=${role}$ AND state IN ('approved','completed') LIMIT 1",
|
||
{"pid": project_id, "role": normalize_role(role)})
|
||
await sor.sqlExe("COMMIT", {})
|
||
return bool(recs)
|
||
|
||
|
||
async def has_pending_blocking_human_task(sor, project_id):
|
||
"""项目是否有阻塞中的人类任务（投标产线无迭代，按 project_id 判定）。"""
|
||
types = "','".join(BLOCKING_HT_TYPES)
|
||
recs = await sor.sqlExe(
|
||
"SELECT COUNT(*) AS c FROM pipeline_human_tasks "
|
||
"WHERE project_id=${pid}$ AND status='pending' "
|
||
"AND task_type IN ('" + types + "')", {"pid": project_id})
|
||
await sor.sqlExe("COMMIT", {})
|
||
return to_int(getattr(recs[0], "c", 0) if recs else 0) > 0
|
||
|
||
|
||
async def create_human_task(sor, project_id, task_type, title, description="",
|
||
assignee_role="owner.superuser", assignee_id="",
|
||
form_schema=None, dedup_by_title=False, task_id=""):
|
||
"""创建人类任务（pipeline_human_tasks）。iteration_id 留空 → 走项目级门禁。
|
||
|
||
同一事项只发一次待办（2026-09-01 机制层不变量）：同项目+同类型已有
|
||
pending 任务 → 直接返回已有 id，不重复创建。防止对账器/agent 每轮
|
||
重复发同类待办把用户淹没。
|
||
|
||
dedup_by_title（2026-09-16 甘肃项目实测 bug）：「事项」粒度是标题而非类型——
|
||
多个章节各自达重做上限都发 general 类型待办时，类型级去重把第 2~N 章的
|
||
升级信号静默吞掉（只剩最先那条，其余章节人工介入信号丢失）。
|
||
True 时按 (task_type+title) 去重：同标题 pending 才复用，不同标题各发一条。
|
||
|
||
项目状态门禁（2026-09-15，与引擎 create_human_task 同款）：项目已删除或
|
||
处于 paused/archived/cancelled/completed → 不发新待办返回 ''（暂停/删除的
|
||
项目不再产生待办；恢复推进后对账器按需补发）。
|
||
"""
|
||
prec = await sor.sqlExe(
|
||
"SELECT status FROM sd_projects WHERE id=${p}$", {"p": project_id or ""})
|
||
await sor.sqlExe("COMMIT", {})
|
||
if not prec:
|
||
logger.info("bid create_human_task skipped: project %s deleted (type=%s)",
|
||
project_id, task_type)
|
||
return ""
|
||
_st = getattr(prec[0], "status", "") or ""
|
||
if _st in ("paused", "archived", "cancelled", "completed"):
|
||
logger.info("bid create_human_task skipped: project %s status=%s (type=%s)",
|
||
project_id, _st, task_type)
|
||
return ""
|
||
if dedup_by_title:
|
||
recs = await sor.sqlExe(
|
||
"SELECT id FROM pipeline_human_tasks WHERE project_id=${pid}$ "
|
||
"AND task_type=${tt}$ AND title=${ti}$ AND status='pending' "
|
||
"ORDER BY created_at DESC LIMIT 1",
|
||
{"pid": project_id, "tt": task_type, "ti": (title or "")[:480]})
|
||
await sor.sqlExe("COMMIT", {})
|
||
if recs:
|
||
_eid = getattr(recs[0], "id", "")
|
||
logger.info("bid create_human_task dedup(title): type=%s title=%s existing=%s",
|
||
task_type, (title or "")[:40], _eid)
|
||
return _eid
|
||
else:
|
||
exist = await find_human_task(sor, project_id, task_type, status="pending")
|
||
if exist:
|
||
logger.info("bid create_human_task dedup: type=%s existing=%s project=%s",
|
||
task_type, exist.get("id"), project_id)
|
||
return exist.get("id")
|
||
hid = new_id()
|
||
await sor.C("pipeline_human_tasks", {
|
||
"id": hid,
|
||
"task_id": task_id or "",
|
||
"step_name": task_type,
|
||
"version": 1,
|
||
"task_type": task_type,
|
||
"assignee_role": assignee_role or "owner.superuser",
|
||
"assignee_id": assignee_id or "",
|
||
"form_schema": json.dumps(form_schema or {}, ensure_ascii=False),
|
||
"status": "pending",
|
||
"project_id": project_id or "",
|
||
"title": (title or "")[:480],
|
||
"description": description or "",
|
||
})
|
||
logger.info("bid create_human_task type=%s id=%s project=%s", task_type, hid, project_id)
|
||
return hid
|
||
|
||
|
||
async def find_human_task(sor, project_id, task_type, status=None):
|
||
"""查项目下指定类型人类任务（最新一条）。"""
|
||
sql = ("SELECT * FROM pipeline_human_tasks WHERE project_id=${pid}$ "
|
||
"AND task_type=${tt}$")
|
||
p = {"pid": project_id, "tt": task_type}
|
||
if status:
|
||
sql += " AND status=${st}$"
|
||
p["st"] = status
|
||
sql += " ORDER BY created_at DESC LIMIT 1"
|
||
recs = await sor.sqlExe(sql, p)
|
||
await sor.sqlExe("COMMIT", {})
|
||
return rec_to_dict(recs[0]) if recs else {}
|
||
|
||
|
||
async def llm_json(prompt, model_name="", retries=1, project_id=""):
|
||
"""调 LLM 并解析 JSON（剥离 markdown code fence）。失败返回 (None, err)。
|
||
|
||
project_id：透传到 llm_usage.project_id（按项目统计费用，2026-09-10）。
|
||
"""
|
||
from pipeline_service.llm_bridge import llm_call
|
||
last_err = ""
|
||
for _ in range(max(1, retries + 1)):
|
||
try:
|
||
raw = await llm_call(prompt, model=model_name or None,
|
||
project_id=project_id or '')
|
||
txt = (raw or "").strip()
|
||
if txt.startswith("```"):
|
||
parts = txt.split("\n", 1)
|
||
txt = parts[1] if len(parts) > 1 else txt
|
||
if "```" in txt:
|
||
txt = txt.rsplit("```", 1)[0]
|
||
txt = txt.strip()
|
||
# 容错：截取第一个 { 到最后一个 }
|
||
if not txt.startswith("{") and "{" in txt:
|
||
txt = txt[txt.find("{"):txt.rfind("}") + 1]
|
||
return json.loads(txt), ""
|
||
except Exception as e:
|
||
last_err = str(e)[:200]
|
||
return None, last_err or "LLM 返回无法解析为 JSON"
|
||
|
||
|
||
async def record(sor, project_id, entity, entity_id, action,
|
||
from_state=None, to_state=None, who=None, agent_id=None, detail=None):
|
||
"""写审计（复用引擎 audit，失败不影响主流程）。"""
|
||
try:
|
||
from pipeline_service.audit import record_audit
|
||
await record_audit(project_id, entity, entity_id, action,
|
||
from_state=from_state, to_state=to_state,
|
||
who=normalize_role(who), agent_id=agent_id,
|
||
detail=detail, sor=sor)
|
||
except Exception as e:
|
||
logger.warning("bid audit failed: %s", str(e)[:120])
|