sino-bc-cli 1.8.41 → 1.8.42

package/dist/skills/biz-line-strategy-generate/scripts/resumable_requests.py

@@ -0,0 +1,243 @@
+"""Agent交接的持久请求；等待只返回，不把进程存活当作请求存活。"""
+from hashlib import sha256
+import json
+from pathlib import Path
+import time
+from uuid import uuid4
+
+from ai_strategy import AiStrategyExhausted, prepare_ai_input, validate_ai_text
+from cleanup import is_link
+from strategy_output import (SCENES, TAG_REVIEW_ATTEMPTS, TAG_REVIEW_SECONDS, choice_key,
+                             map_tag_choices, tag_review_fallback, tag_review_strategies)
+from task_state import atomic_json, file_digest, read_task, shared_lock
+
+
+class PendingRequest(Exception):
+    """正常等待Agent的非终态，调用方不能按业务失败保存或清理。"""
+    def __init__(self, event):
+        super().__init__('等待 Agent 提交响应')
+        self.event = event
+
+
+def _read(path):
+    if is_link(path):
+        raise ValueError('请求状态不能是链接')
+    value = json.loads(path.read_text(encoding='utf-8'))
+    if not isinstance(value, dict):
+        raise ValueError('请求状态必须是对象')
+    return value
+
+
+def _line(task_root, line_key, generation, root):
+    """仅在任务短锁内核验当前代次；清理/换代与提交共用这个边界。"""
+    task = read_task(task_root)
+    line = task.get('lines', {}).get(line_key)
+    if not isinstance(line, dict) or line.get('generation') != generation \
+            or line.get('status') in ('completed', 'failed', 'cancelled', 'cleanup', 'closed') \
+            or Path(line.get('workPath', '')).resolve() != root or not root.is_dir() or is_link(root):
+        raise ValueError('请求所属任务已结束、目录已清理或数据代次已变化')
+    if not root.is_relative_to(task_root) or root == task_root:
+        raise ValueError('请求目录不属于当前任务')
+    return line
+
+
+def _digest(packet):
+    return sha256(json.dumps(packet, sort_keys=True, ensure_ascii=False).encode('utf-8')).hexdigest()
+
+
+def _advance(kind, root, cancel, progress, context, packet_factory, validate, *, seconds, attempts, fallback=None):
+    root, task_root = Path(root).resolve(), Path(context['taskPath']).resolve()
+    state_path = root / f'{kind}.state.json'
+    events, pending, result, exhausted = [], None, None, False
+    with shared_lock(task_root):
+        _line(task_root, context['lineKey'], context['generation'], root)
+        if cancel.is_set():
+            raise InterruptedError('任务已取消')
+        state = _read(state_path) if state_path.exists() else {'version': 1, 'failures': []}
+        if state.get('version') != 1:
+            raise ValueError('请求状态版本不兼容')
+        if state.get('status') == 'accepted':
+            return state['value']
+        if state.get('status') == 'closed':
+            raise ValueError('请求已关闭')
+        current = state.get('current')
+        if current:
+            packet = _read(Path(current['event']['request_path']))
+            if _digest(packet) != current['digest']:
+                raise ValueError('请求内容与已登记状态不一致')
+            receipt = current.get('receipt')
+            reason = None
+            if receipt is not None:
+                if receipt['acceptedAt'] >= packet['expiresAt']:
+                    raise ValueError('请求接收时间不在有效期内')
+                try:
+                    result = validate(packet, receipt['body'])
+                except (ValueError, TypeError, KeyError, UnicodeError) as exc:
+                    reason = str(exc)
+                else:
+                    state.update(status='accepted', value=result, consumedAt=time.time())
+                    atomic_json(state_path, state)
+                    events.append({**current['event'], 'event': kind.replace('-', '_') + '_accepted',
+                                   'acceptedAt': receipt['acceptedAt'], 'consumedAt': state['consumedAt']})
+            elif time.time() >= packet['expiresAt']:
+                reason = '等待 Agent 回包超时'
+            else:
+                pending = current['event']
+            if reason is not None:
+                state['failures'].append({'reviewAttempt': current['event']['reviewAttempt'], 'reason': reason})
+                events.append({**current['event'], 'event': kind.replace('-', '_') + '_rejected', 'reason': reason})
+                state.pop('current')
+                atomic_json(state_path, state)
+        if result is None and pending is None:
+            review_attempt = len(state['failures']) + 1
+            if review_attempt > attempts:
+                if fallback is None:
+                    exhausted = True
+                else:
+                    result, missing = fallback()
+                    state.update(status='accepted', value=result, consumedAt=time.time(),
+                                 fallback={'event': 'tag_review_fallback', 'bizLineId': context['bizLineId'],
+                                           'attempt': context['attempt'], 'reviewAttempts': attempts,
+                                           'failures': state['failures'], 'missingOtherScenes': missing})
+                    atomic_json(state_path, state)
+            else:
+                issued = time.time()
+                identifier = uuid4().hex
+                packet = {**packet_factory(identifier), **context, 'resumableProtocol': 1,
+                          'reviewAttempt': review_attempt, 'issuedAt': issued, 'expiresAt': issued + seconds}
+                request = root / f'{kind}.{review_attempt}.request.json'
+                response = root / f'{kind}.{review_attempt}.response.json'
+                packet['responsePath'] = str(response)
+                id_key = 'reviewId' if kind == 'tag-review' else 'requestId'
+                pending = {'event': kind.replace('-', '_') + '_required', **context, id_key: identifier,
+                           'reviewAttempt': review_attempt, 'issuedAt': issued, 'expiresAt': packet['expiresAt'],
+                           'request_path': str(request), 'response_path': str(response)}
+                atomic_json(request, packet)
+                state.update(status='pending', current={'event': pending, 'digest': _digest(packet)})
+                atomic_json(state_path, state)
+                events.append(pending)
+    # 回调可能立即提交，不能在任务短锁内调用。
+    for event in events:
+        progress(event)
+    if exhausted:
+        raise AiStrategyExhausted('AI 策略生成三次失败：' + '；'.join(x['reason'] for x in state['failures']))
+    if pending is not None:
+        raise PendingRequest(pending)
+    return result
+
+
+def advance_tags(row, dictionaries, evidence, root, cancel, progress, *,
+                 biz_line_id, attempt, task_root, line_key, generation):
+    """沿用原候选映射、两轮审核及其他标签兜底；本次只推进一个外部等待点。"""
+    strategies = tag_review_strategies(row, dictionaries, evidence)
+    def packet_factory(identifier):
+        return {'reviewId': identifier, 'submissionMode': 'choice-key-v1',
+                'strategies': {key: {**value, 'labels': [
+                    {**label, 'choiceKey': choice_key(identifier, key, label['id'])}
+                    for label in value['labels']]} for key, value in strategies.items()}}
+    def validate(packet, body):
+        mapped = map_tag_choices(packet, body)
+        return {key: [{'id': item['id'], 'reason': item['reason']} for item in mapped[key]] for key in SCENES}
+    context = {'taskPath': str(Path(task_root).resolve()), 'lineKey': line_key, 'generation': generation,
+               'bizLineId': biz_line_id, 'attempt': attempt}
+    result = _advance('tag-review', root, cancel, progress, context, packet_factory, validate,
+                      seconds=TAG_REVIEW_SECONDS, attempts=TAG_REVIEW_ATTEMPTS,
+                      fallback=lambda: tag_review_fallback(dictionaries))
+    # 兜底已接受但父工作流尚未记结果时中断，恢复仍须携带兜底说明。
+    with shared_lock(Path(task_root).resolve()):
+        fallback = _read(Path(root) / 'tag-review.state.json').get('fallback')
+    if fallback:
+        progress(fallback)
+    return result
+
+
+def advance_ai(root, workbook, prompt_path, cancel, progress, *, biz_line_id, attempt,
+               task_root, line_key, generation, wait_seconds=900, require_learning=False):
+    """AI文案依旧由Agent生成；有效期和审核次数跨调用持久化。"""
+    if wait_seconds <= 0 or not Path(workbook).is_file():
+        raise ValueError('AI请求缺少有效工作簿或等待期限')
+    prompt = Path(prompt_path).read_text(encoding='utf-8')
+    if not prompt.strip():
+        raise ValueError('AI策略提示词为空')
+    if cancel.is_set():
+        raise InterruptedError('任务已取消')
+    # 索引准备在发出请求和短锁之前完成；后续调用、换轮复用同一已提交索引。
+    prepared_path = Path(root) / 'ai-input.json'
+    if prepared_path.exists():
+        record = _read(prepared_path)
+        prepared = record['prepared']
+        if file_digest(Path(workbook)) != record['workbookDigest'] or \
+                file_digest(Path(prepared['detailIndexPath'])) != record['indexDigest']:
+            raise ValueError('AI明细工作簿或索引与准备记录不一致')
+    else:
+        prepared = prepare_ai_input(Path(workbook))
+        atomic_json(prepared_path, {'prepared': prepared, 'workbookDigest': file_digest(Path(workbook)),
+                                   'indexDigest': file_digest(Path(prepared['detailIndexPath']))})
+    def packet_factory(identifier):
+        packet = {'requestId': identifier, 'prompt': prompt, 'promptPath': str(prompt_path),
+                  'workbookPath': str(workbook), 'worksheetName': '明细',
+                  'waitSeconds': wait_seconds, 'deadlineSource': 'request', **prepared}
+        if require_learning:
+            packet['outputContract'] = ('四段策略各以独立末段 Learning（有效/无效/待观察）：说明 结束；'
+                                        '每段只能有一个 Learning，正文和冒号后的说明均非空，可保留换行。')
+        return packet
+    def validate(_packet, body):
+        if not isinstance(body, dict) or set(body) != {'text'}:
+            raise ValueError('AI响应必须只包含text')
+        return validate_ai_text(body['text'], require_learning=require_learning, count_facts=prepared['countFacts'])
+    context = {'taskPath': str(Path(task_root).resolve()), 'lineKey': line_key, 'generation': generation,
+               'bizLineId': biz_line_id, 'attempt': attempt}
+    return _advance('ai-strategy', root, cancel, progress, context, packet_factory, validate,
+                    seconds=wait_seconds, attempts=3)
+
+
+def _submit(request, identifier, body, kind):
+    request = Path(request).absolute()
+    initial = _read(request)
+    if initial.get('resumableProtocol') != 1:
+        raise ValueError('不是可恢复请求')
+    task_root = Path(initial['taskPath']).resolve()
+    root = request.parent.resolve()
+    with shared_lock(task_root):
+        packet = _read(request)
+        _line(task_root, packet['lineKey'], packet['generation'], root)
+        state_path = root / f'{kind}.state.json'
+        state = _read(state_path)
+        current = state.get('current')
+        id_key = 'reviewId' if kind == 'tag-review' else 'requestId'
+        if not current or state.get('status') not in ('pending', 'accepted') \
+                or current['event']['request_path'] != str(request) \
+                or packet.get(id_key) != identifier or current['digest'] != _digest(packet):
+            raise ValueError('请求已关闭、被替代或身份不一致')
+        receipt = current.get('receipt')
+        response = Path(current['event']['response_path'])
+        if receipt is not None:
+            if receipt['body'] == body:
+                if not response.exists():
+                    atomic_json(response, {**receipt, 'bizLineId': packet['bizLineId'], id_key: identifier,
+                                           'generation': packet['generation'], 'attempt': packet['attempt']})
+                return response
+            raise ValueError('请求已提交，禁止用不同内容覆盖')
+        if time.time() >= packet['expiresAt']:
+            raise ValueError('请求已过期')
+        if kind == 'tag-review':
+            map_tag_choices(packet, body)
+        elif not isinstance(body, dict) or set(body) != {'text'} or not isinstance(body['text'], str):
+            raise ValueError('AI响应必须只包含字符串text')
+        # 接收凭据是唯一提交点；先落盘凭据，副本写入前中断也能消费。
+        receipt = {'body': body, 'acceptedAt': time.time()}
+        if receipt['acceptedAt'] >= packet['expiresAt']:
+            raise ValueError('请求已过期')
+        current['receipt'] = receipt
+        atomic_json(state_path, state)
+        atomic_json(response, {**receipt, 'bizLineId': packet['bizLineId'], id_key: identifier,
+                               'generation': packet['generation'], 'attempt': packet['attempt']})
+        return response
+
+
+def submit_tags_response(request, review_id, selection):
+    return _submit(request, review_id, selection, 'tag-review')
+
+
+def submit_ai_response(request, request_id, body):
+    return _submit(request, request_id, body, 'ai-strategy')