967 lines
60 KiB
Python
967 lines
60 KiB
Python
"""Database receive + native original-account send, without window interaction."""
|
||
from __future__ import annotations
|
||
import hashlib
|
||
import json
|
||
import os
|
||
import re
|
||
from pathlib import Path
|
||
import threading
|
||
import time
|
||
from runtime_paths import application_data_dir
|
||
from reply_session_policy import excluded_session_reason
|
||
from contact_reply_guard import (CONTACT_REASON, conversation_contact_reason, system_contact_status, rejected_contact_reason,
|
||
contact_event_order, contact_peer, latest_contact_notice, current_customer_relation, real_customer_event)
|
||
from wecom_native_sender import NativeSender,NativeUnavailable,DeliveryUnknown,DeliveryFailed,SendCancelled,discover
|
||
|
||
|
||
def protocol_queue_path():return application_data_dir()/'pending_replies.protocol.json'
|
||
|
||
def model_context_text(context):
|
||
"""Respect saved memory settings while retaining the unanswered message batch."""
|
||
import ai_config
|
||
from datetime import datetime
|
||
messages=list(context.get('messages') or [])
|
||
if not messages:return str(context.get('text') or '')
|
||
start=len(messages)-1
|
||
while start>0 and not messages[start-1].get('is_self'):start-=1
|
||
if getattr(ai_config,'AI_CONTEXT_ENABLED',True):
|
||
rounds=max(1,min(50,int(getattr(ai_config,'AI_CONTEXT_MAX_ROUNDS',5) or 5)))
|
||
start=min(start,max(0,len(messages)-rounds*2))
|
||
lines=[]
|
||
for item in messages[start:]:
|
||
speaker='我' if item.get('is_self') else context.get('display_name','客户')
|
||
stamp=datetime.fromtimestamp(float(item.get('send_time') or time.time())).strftime('%Y/%m/%d %H:%M:%S')
|
||
lines.extend((f'{speaker} {stamp}',str(item.get('content') or '')))
|
||
return '\n'.join(lines)
|
||
|
||
def _voice_batch_fingerprint(context):
|
||
"""Only voice-containing unanswered batches need cache-content invalidation."""
|
||
from voice_messages import is_voice, unanswered_messages
|
||
batch=unanswered_messages(context)
|
||
if not any(is_voice(message) for message in batch):return ''
|
||
fields=('account','conv_id','server_id','dedup_key','content_type','content',
|
||
'voice_status','voice_transcribed','voice_binding')
|
||
payload=[[message.get(field) for field in fields] for message in batch]
|
||
return hashlib.sha256(json.dumps(payload,ensure_ascii=False,separators=(',',':')).encode('utf-8')).hexdigest()
|
||
|
||
|
||
def _is_text_message(message):
|
||
from voice_messages import verified_transcript
|
||
if verified_transcript(message):return True
|
||
try:return int(message.get('content_type') or 0) in (0,1,2)
|
||
except (TypeError,ValueError):return False
|
||
|
||
MANUAL_MEDIA_REASON = '当前未回复消息包含图片、语音或其他非文本内容，协议版需人工处理'
|
||
MANUAL_BATCH_REASON = '连续未回复消息超过 100 条，无法保证问题完整，请人工处理后继续'
|
||
MANUAL_NON_TEXT_REASON = '当前协议版只自动处理文本消息'
|
||
|
||
|
||
def _send_protection(state):
|
||
"""Use either durable field; missing/old schema must not enable a replay."""
|
||
status=str(state.get('send_state') or '')
|
||
stage=str(state.get('stage') or '')
|
||
if status=='sending' or stage=='sending':return 'sending'
|
||
if status in ('uncertain','unknown','sent_uncommitted') or stage in ('receipt_check','uncertain','unknown','sent_uncommitted'):
|
||
return 'uncertain'
|
||
if status=='failed' or stage=='failed':return 'failed'
|
||
return 'uncertain' if status else ''
|
||
|
||
|
||
def _restore_review_details(state):
|
||
# Existing persisted queues predate the desktop's explicit review fields.
|
||
# Recover presentation metadata without granting approval or replaying sends.
|
||
if state.get('awaiting_review') and not state.get('approved'):
|
||
state['review_reason'] = str(state.get('review_reason') or state.get('stage_detail') or '人工审核后点击“通过并发送”')
|
||
if state.get('stage') == 'error' and state.get('last_error') in (
|
||
MANUAL_MEDIA_REASON, MANUAL_BATCH_REASON, MANUAL_NON_TEXT_REASON):
|
||
state.update(manual_required=True, manual_reason=state['last_error'])
|
||
|
||
|
||
def _unanswered_manual_reason(context):
|
||
# A text caption after media is still a media question. Human replies and
|
||
# restored-contact notices separate the current batch from old history.
|
||
count=0
|
||
for message in reversed((context or {}).get('messages') or []):
|
||
if message.get('is_self') or system_contact_status(message)=='restored':break
|
||
count+=1
|
||
if not _is_text_message(message):return MANUAL_MEDIA_REASON
|
||
if count>100:return MANUAL_BATCH_REASON
|
||
return ''
|
||
|
||
def _session_exclusion(source):
|
||
source=source if isinstance(source,dict) else {}
|
||
return excluded_session_reason(name=source.get('display_name') or '',
|
||
conv_id=source.get('conv_id') or '',metadata=source)
|
||
|
||
|
||
def session_key(account,conversation):return hashlib.blake2b((account+'\0'+conversation).encode(),digest_size=40).hexdigest()
|
||
|
||
class ProtocolBot:
|
||
def __init__(self,*,db=None,sender=None,identity=None,path=None,generate=None,stop_event=None,reply_text='',log=None,progress=None,review_assistant=None):
|
||
self.stop_event=stop_event or threading.Event();self.log=log or print;self.reply_text=reply_text
|
||
self.progress_cb=progress;self._progress_text=''
|
||
self._completed_polls=0;self._last_poll_log=time.monotonic()
|
||
self._contact_scan_at=0.;self._contact_scan_offset=0;self._contact_logs={}
|
||
self.identity=identity or discover();self.account=self.identity['accountId'];self.pid=self.identity['pid']
|
||
self.path=Path(path) if path else protocol_queue_path();self.path.parent.mkdir(parents=True,exist_ok=True)
|
||
self._lock=threading.RLock();self._owned_db=db is None
|
||
self._review_assistant=review_assistant;self._assistant_warning=''
|
||
if db is None:
|
||
from reply_database import LiveReplyDatabase
|
||
db=LiveReplyDatabase._open_database(account=self.account)
|
||
self.db=db
|
||
if not self.db.health_check():raise NativeUnavailable('消息数据库不可读，协议监听不能启动')
|
||
self.sender=sender or NativeSender(self.db,application_data_dir()/'protocol_sends.sqlite3')
|
||
self.generate=generate or self._generate
|
||
self.message_batch_window_seconds=8.;self.send_delay_seconds=2.;self.send_mode='auto'
|
||
self.reply_count=0;self.false_pos_rows=[];self.security_verification_required=False
|
||
self._window_ready=True;self._reply_wakeup=threading.Event();self.needs_attention=False
|
||
self._since=time.time();self._pending={};self._seen={};self._contact_blocked={};self._manual_handoffs={};self._assistant_cancellations={}
|
||
if self.path.exists():
|
||
raw=json.loads(self.path.read_text(encoding='utf-8'))
|
||
if not isinstance(raw,dict) or not isinstance(raw.get('pending',{}),dict):raise NativeUnavailable('协议队列文件格式错误，已停止启动')
|
||
self._pending={k:v for k,v in raw.get('pending',{}).items() if isinstance(v,dict)}
|
||
self._manual_handoffs=raw.get('manual_handoffs',{})
|
||
if not isinstance(self._manual_handoffs,dict):raise NativeUnavailable('人工接管记录格式错误，已停止启动')
|
||
self._assistant_cancellations=raw.get('assistant_cancellations',{})
|
||
if not isinstance(self._assistant_cancellations,dict):raise NativeUnavailable('审核提醒取消记录格式错误')
|
||
self._assistant_cancellations={k:v for k,v in self._assistant_cancellations.items() if isinstance(v,dict)}
|
||
self._contact_blocked=raw.get('contactBlocked',{})
|
||
if not isinstance(self._contact_blocked,dict):raise NativeUnavailable('联系人跳过记录格式错误')
|
||
self._seen=raw.get('seen',{})
|
||
if not isinstance(self._seen,dict):raise NativeUnavailable('协议去重记录格式错误')
|
||
for key,state in list(self._pending.items()):
|
||
# Filtering old drafts must never erase an attempted send's evidence.
|
||
if state.get('account')==self.account and not _send_protection(state) and _session_exclusion(state):
|
||
if state.get('dedup_key'):self._seen[key]=state['dedup_key']
|
||
self._pending.pop(key,None)
|
||
continue
|
||
_restore_review_details(state)
|
||
lookup=getattr(self.sender,'lookup',None)
|
||
saved=lookup(state.get('dedup_key','')) if lookup else None
|
||
if saved and saved['status']=='confirmed':
|
||
self._assistant_call('record_automated_send',state,saved.get('result') or {},default=None)
|
||
self._pending.pop(key,None)
|
||
continue
|
||
if _send_protection(state) in ('sending','uncertain'):state.update(send_state='uncertain',stage='receipt_check',last_error=state.get('last_error') or '上次发送结果待核对，禁止自动重发')
|
||
elif state.get('stage')=='generating':state.update(stage='queued',ready_at=time.time())
|
||
# A restart preserves the affected conversation's no-replay protection.
|
||
self.needs_attention=any(s.get('account')==self.account and _send_protection(s)=='uncertain' for s in self._pending.values())
|
||
self._save()
|
||
def _assistant_call(self,method,*args,default=False):
|
||
"""Optional coordination cannot stop the protocol listener or approve work."""
|
||
try:
|
||
if self._review_assistant is None:
|
||
from review_assistant import ReviewAssistantCoordinator
|
||
self._review_assistant=ReviewAssistantCoordinator(
|
||
root=self.path.parent,account=self.account,pid=self.pid,db=self.db,log=self.log)
|
||
assistant=self._review_assistant
|
||
if method not in ('cancel_review','record_automated_send') and not assistant.enabled():return default
|
||
return getattr(assistant,method)(*args)
|
||
except Exception as exc:
|
||
warning=f'{method}:{type(exc).__name__}'
|
||
if warning!=self._assistant_warning:
|
||
self._assistant_warning=warning
|
||
try:self.log('[医疗助理] 协作状态暂不可用，协议监听继续；'+warning)
|
||
except Exception:pass
|
||
return default
|
||
|
||
def _queue_assistant_cancellation(self,state):
|
||
# Persist only an exact episode target, never a conversation-wide retry
|
||
# that could cancel a later independent risk review.
|
||
review_id=state.get('assistant_review_id')
|
||
if review_id:
|
||
self._assistant_cancellations[review_id]={
|
||
'account':state.get('account'), 'conv_id':state.get('conv_id'),
|
||
'assistant_review_id':review_id}
|
||
|
||
def _flush_assistant_cancellations(self):
|
||
with self._lock:items=list(self._assistant_cancellations.items())
|
||
for review_id,state in items:
|
||
if state.get('account')!=self.account:continue
|
||
if self._assistant_call('cancel_review',state) is not True:continue
|
||
with self._lock:
|
||
if self._assistant_cancellations.get(review_id) is not state:continue
|
||
self._assistant_cancellations.pop(review_id,None)
|
||
try:self._save()
|
||
except Exception:
|
||
self._assistant_cancellations[review_id]=state
|
||
raise
|
||
|
||
def _assistant_cancellation_pending(self,state):
|
||
with self._lock:
|
||
return any(item.get('account')==self.account and item.get('conv_id')==state.get('conv_id')
|
||
for item in self._assistant_cancellations.values())
|
||
|
||
def _assistant_recipient(self,conv_id):
|
||
return bool(self._assistant_call('is_recipient',conv_id))
|
||
|
||
def _assistant_pending(self,state):
|
||
# Preserve an already-registered review if coordination storage is
|
||
# temporarily unavailable; never interpret a read failure as approval.
|
||
if state.get('assistant_review_id') and not state.get('approved'):return True
|
||
return bool(self._assistant_call('has_pending',state.get('conv_id','')))
|
||
|
||
@staticmethod
|
||
def _assistant_attention(state):
|
||
# Registration is a notification decision, never permission to send or
|
||
# to clear protected delivery evidence. Explicitly stopped tasks remain
|
||
# stopped even if an old episode is still present in coordination storage.
|
||
if state.get('cancel_requested') or state.get('stage') in ('cancelled','disabled','paused'):
|
||
return False
|
||
from review_state import task_review_state
|
||
flags=task_review_state(state)
|
||
return bool(flags['awaitingReview'] or flags['needsHuman'])
|
||
|
||
def _register_assistant_review(self,key,state,context=None):
|
||
if not self._assistant_call('enabled') or state.get('account')!=self.account:return
|
||
if self._assistant_cancellation_pending(state) or not self._assistant_attention(state):return
|
||
if _send_protection(state)=='sending':return
|
||
if context is None:
|
||
context=self.db.get_conversation_context_by_id(self.account,state['conv_id'],limit=500)
|
||
review_id=self._assistant_call('ensure_review',state,context,default='')
|
||
if review_id and review_id!=state.get('assistant_review_id'):
|
||
with self._lock:
|
||
if self._pending.get(key) is state:
|
||
state['assistant_review_id']=review_id
|
||
self._save()
|
||
|
||
@staticmethod
|
||
def _message_order(message):
|
||
try:return (float(message.get('send_time') or 0),int(message.get('rowid') or 0))
|
||
except (TypeError,ValueError):return (0.0,0)
|
||
|
||
def _assistant_context(self,state,context):
|
||
# A phone reply may reach the local DB after a newer customer question.
|
||
# Only this proven resumed batch needs chronological context; normal DB
|
||
# polling remains in authoritative row order.
|
||
if not state.get('assistant_resume_evidence') or not context:return context
|
||
messages=list(context.get('messages') or [])
|
||
messages.sort(key=self._message_order)
|
||
if not messages:return context
|
||
updated={**context,'messages':messages,'last_message':messages[-1]}
|
||
updated['text']=model_context_text(updated)
|
||
return updated
|
||
|
||
def _reconcile_assistant_review(self,key,state,context=None):
|
||
if not self._assistant_call('enabled'):return False
|
||
from review_assistant import manual_completion_blocked
|
||
if (state.get('account')!=self.account or manual_completion_blocked(state)
|
||
or self._assistant_cancellation_pending(state) or state.get('cancel_requested')
|
||
or state.get('stage') in ('cancelled','disabled','paused')
|
||
or not (self._assistant_attention(state) or state.get('assistant_review_id')
|
||
or self._assistant_call('has_pending',state.get('conv_id','')))):
|
||
return False
|
||
if context is None:
|
||
context=self.db.get_conversation_context_by_id(self.account,state['conv_id'],limit=500)
|
||
self._register_assistant_review(key,state,context)
|
||
evidence=self._assistant_call('reconcile',state,context,default=None)
|
||
if not isinstance(evidence,dict) or not evidence:return False
|
||
if (evidence.get('review_id') and state.get('assistant_review_id')
|
||
and evidence['review_id']!=state['assistant_review_id']):return False
|
||
evidence_order=self._message_order(evidence)
|
||
following=[m for m in (context or {}).get('messages',[])
|
||
if m.get('account')==self.account and m.get('conv_id')==state.get('conv_id')
|
||
and m.get('is_self') is False and m.get('dedup_key')
|
||
and self._message_order(m)>evidence_order]
|
||
followup=max(following,key=self._message_order) if following else None
|
||
with self._lock:
|
||
if self._pending.get(key) is not state or manual_completion_blocked(state) or state.get('cancel_requested'):return False
|
||
previous_seen=self._seen.get(key)
|
||
previous_handoff=self._manual_handoffs.get(key)
|
||
if _send_protection(state):
|
||
# A verified later human reply finishes the customer task, not
|
||
# the ambiguous old delivery. Preserve its complete evidence;
|
||
# never rewrite the native journal or claim that draft was sent.
|
||
self._manual_handoffs[key]={
|
||
'state':json.loads(json.dumps(state,ensure_ascii=False)),
|
||
'handed_off_at':time.time(),'completed_by_human':True,
|
||
'completion_reason':'verified_human_reply','evidence':dict(evidence),
|
||
'receipt_checked_by_user':False,'delivery_confirmed':False}
|
||
if state.get('dedup_key'):self._seen[key]=state['dedup_key']
|
||
self._pending.pop(key,None)
|
||
try:
|
||
if followup:
|
||
if self._seen.get(key)==followup['dedup_key']:self._seen.pop(key,None)
|
||
self._upsert({**followup,'assistant_resume_evidence':evidence})
|
||
else:self._save()
|
||
except Exception:
|
||
self._pending[key]=state
|
||
if previous_seen is None:self._seen.pop(key,None)
|
||
else:self._seen[key]=previous_seen
|
||
if previous_handoff is None:self._manual_handoffs.pop(key,None)
|
||
else:self._manual_handoffs[key]=previous_handoff
|
||
raise
|
||
try:
|
||
from queue_log import QueueLog
|
||
label='人工已完成'
|
||
QueueLog().append(key,state.get('display_name',''),label,
|
||
'已检测到当前企微账号人工回复；本轮旧AI草稿已丢弃，后续消息重新执行风控')
|
||
self.log('[协议'+label+'] '+state.get('display_name','')+' · 已人工回复，本轮旧AI草稿已丢弃')
|
||
except Exception:pass
|
||
self._listening_progress()
|
||
return True
|
||
|
||
def _save(self):
|
||
with self._lock:
|
||
temp=self.path.with_suffix('.tmp')
|
||
with temp.open('w',encoding='utf-8') as f:
|
||
json.dump({'schemaVersion':1,'transport':'protocol','pending':self._pending,'seen':self._seen,'contactBlocked':self._contact_blocked,'manual_handoffs':self._manual_handoffs,'assistant_cancellations':self._assistant_cancellations},f,ensure_ascii=False,indent=2);f.flush();os.fsync(f.fileno())
|
||
os.replace(temp,self.path)
|
||
def _progress(self,text):
|
||
if self.stop_event.is_set() or text==self._progress_text:return
|
||
self._progress_text=text
|
||
if self.progress_cb:
|
||
try:self.progress_cb(text)
|
||
except Exception:pass # Display failures must not interrupt delivery.
|
||
|
||
def _listening_progress(self):
|
||
with self._lock:
|
||
pending=[s for s in self._pending.values() if s.get('account')==self.account]
|
||
uncertain=sum(_send_protection(s)=='uncertain' for s in pending)
|
||
self.needs_attention=bool(uncertain)
|
||
if uncertain:
|
||
self._progress(f'协议监听中 · {uncertain} 个会话发送结果待核对，其他会话继续处理')
|
||
elif any(s.get('stage') not in ('awaiting_review','error','failed','receipt_check') for s in pending):
|
||
self._progress(f'协议监听中 · 待处理 {len(pending)} 个会话')
|
||
elif any(s.get('awaiting_review') for s in pending):
|
||
count=sum(bool(s.get('awaiting_review')) for s in pending)
|
||
self._progress(f'协议监听中 · {count} 个会话待审核')
|
||
elif pending:
|
||
self._progress(f'协议监听中 · {len(pending)} 个会话待人工处理')
|
||
else:
|
||
self._progress('协议监听中 · 等待新消息')
|
||
|
||
def _stage(self,key,stage,detail='',error=''):
|
||
with self._lock:
|
||
if key not in self._pending:return
|
||
s=self._pending[key];now=time.time();s.update(stage=stage,stage_detail=detail,stage_started_at=now,updated_at=now,last_error=error)
|
||
self._save()
|
||
self._register_assistant_review(key,s)
|
||
phase={'queued':'等待消息合并','generating':'正在生成回复','awaiting_review':'等待审核',
|
||
'sending':'正在协议发送并核对回执','receipt_check':'发送结果待人工核对',
|
||
'failed':'发送失败，待人工处理','error':'处理异常，待人工处理'}.get(stage,stage)
|
||
self._progress(f"{phase} · {s.get('display_name','')}")
|
||
self.log(f"[协议处理] {s.get('display_name','')} · {detail or phase}"+(f'；{error}' if error else ''))
|
||
try:
|
||
from queue_log import QueueLog
|
||
QueueLog().append(key,s.get('display_name',''),{'queued':'入队','generating':'生成回复','awaiting_review':'待审核','sending':'发送','receipt_check':'核对回执','failed':'发送失败'}.get(stage,stage),detail or error)
|
||
except Exception:pass
|
||
@staticmethod
|
||
def _contact_anchor(message):
|
||
return {field:message.get(field) for field in
|
||
('account','conv_id','send_time','rowid','server_id','dedup_key')}
|
||
|
||
def _contact_log(self,key,event,detail):
|
||
token=(event,detail)
|
||
if self._contact_logs.get(key)==token:return
|
||
self._contact_logs[key]=token
|
||
self.log('[协议联系人核验] '+detail)
|
||
|
||
def _skip_contact(self,key,display_name,event='',reason=CONTACT_REASON,*,source=None,context=None,rejected=False):
|
||
with self._lock:
|
||
old=self._contact_blocked.get(key)
|
||
state=self._pending.get(key) or {}
|
||
source=source or (latest_contact_notice(context) if context else None) or state.get('database_event') or {}
|
||
account=source.get('account') or state.get('account') or self.account
|
||
conv_id=source.get('conv_id') or state.get('conv_id') or (old.get('conv_id') if isinstance(old,dict) else '')
|
||
anchor=self._contact_anchor(source)
|
||
rejected_at=time.time() if rejected else 0.
|
||
if isinstance(old,dict):
|
||
if contact_event_order(old.get('anchor') or {})>contact_event_order(anchor):anchor=old['anchor']
|
||
rejected_at=max(rejected_at,float(old.get('rejected_at') or 0))
|
||
self._contact_blocked[key]={'schemaVersion':2,'account':account,'conv_id':conv_id,
|
||
'anchor':anchor,'rejected_at':rejected_at,'observed_at':time.time(),'skipped_event':event}
|
||
self._pending.pop(key,None)
|
||
if event:self._seen[key]=event
|
||
self._save()
|
||
self._contact_log(key,event,f'{display_name} · {reason}；继续监听，新的客户消息将重新核验')
|
||
|
||
def _contact_recheck(self,message,context,blocked,*,in_flight=False):
|
||
"""Recheck one never-attempted new question; not proof friendship returned."""
|
||
account,conv_id=self.account,message.get('conv_id')
|
||
if (not isinstance(context,dict) or context.get('account')!=account or context.get('conv_id')!=conv_id
|
||
or not real_customer_event(message,account,conv_id)):
|
||
return False,None,'客户消息身份尚未核验'
|
||
last=context.get('last_message') or {}
|
||
if last.get('dedup_key')!=message.get('dedup_key') or not real_customer_event(last,account,conv_id):
|
||
return False,None,'当前消息已变化或已经人工回复'
|
||
notice=latest_contact_notice(context)
|
||
anchor={};rejected_at=0.
|
||
if isinstance(blocked,dict):
|
||
if blocked.get('account')!=account or blocked.get('conv_id')!=conv_id:
|
||
return False,None,'联系人限制记录所属账号或会话不符'
|
||
anchor=blocked.get('anchor') or {}
|
||
rejected_at=float(blocked.get('rejected_at') or 0)
|
||
elif blocked:
|
||
# Older releases stored discovery time, which can be days after the
|
||
# actual notice. Prefer the source notice; never reset its clock.
|
||
anchor={'send_time':float(blocked),'rowid':0}
|
||
if notice and system_contact_status(notice)=='blocked':anchor=self._contact_anchor(notice)
|
||
if notice and system_contact_status(notice)=='blocked':
|
||
if contact_event_order(notice)>contact_event_order(anchor):anchor=self._contact_anchor(notice)
|
||
boundary=contact_event_order(anchor);order=contact_event_order(message)
|
||
if not boundary[0] or order<=boundary or (boundary[1] and order[1]<=boundary[1]):
|
||
return False,None,'没有晚于原联系人限制的新客户消息'
|
||
if rejected_at and order[0]<=rejected_at:
|
||
return False,None,'消息早于最近一次实际拒收，禁止重试旧问题'
|
||
restored=bool(notice and system_contact_status(notice)=='restored'
|
||
and contact_event_order(notice)>boundary and contact_event_order(notice)[0]>rejected_at)
|
||
if not restored and not current_customer_relation(context):
|
||
return False,None,'当前账号客户关系尚未核验为有效'
|
||
if not in_flight:
|
||
lookup=getattr(self.sender,'lookup',None)
|
||
if not callable(lookup):return False,None,'发送记录尚不可核验，保留原限制'
|
||
try:attempt=lookup(message['dedup_key'])
|
||
except Exception:return False,None,'发送记录读取失败，保留原限制'
|
||
if attempt is not None:return False,None,'此消息已有发送记录，禁止重发'
|
||
evidence={'account':account,'conv_id':conv_id,'anchor':anchor,'rejected_at':rejected_at}
|
||
return True,evidence,''
|
||
|
||
def _contact_context(self,state,context):
|
||
evidence=state.get('contact_retry_evidence')
|
||
if not evidence or not context:return context
|
||
boundary=contact_event_order(evidence.get('anchor') or {})
|
||
rejected_at=float(evidence.get('rejected_at') or 0)
|
||
# Old unanswerable batches and their system notices are not this new
|
||
# question. Voice/manual/risk handling sees only the eligible new batch.
|
||
messages=[message for message in context.get('messages') or []
|
||
if contact_event_order(message)>boundary
|
||
and (not boundary[1] or contact_event_order(message)[1]>boundary[1])
|
||
and (not rejected_at or contact_event_order(message)[0]>rejected_at)]
|
||
if not messages:return context
|
||
updated={**context,'messages':messages,'last_message':messages[-1]}
|
||
updated['text']=model_context_text(updated)
|
||
return updated
|
||
|
||
def _recover_blocked_contacts(self):
|
||
now=time.monotonic()
|
||
if now<self._contact_scan_at:return
|
||
self._contact_scan_at=now+5.
|
||
with self._lock:items=list(self._contact_blocked.items())
|
||
if not items:return
|
||
start=self._contact_scan_offset%len(items)
|
||
self._contact_scan_offset=start+min(2,len(items))
|
||
for offset in range(min(2,len(items))):
|
||
key,blocked=items[(start+offset)%len(items)]
|
||
with self._lock:
|
||
if key in self._pending:continue
|
||
seen=str(self._seen.get(key) or '')
|
||
if isinstance(blocked,dict):
|
||
if blocked.get('account')!=self.account:continue
|
||
conv_id=blocked.get('conv_id') or ''
|
||
else:
|
||
# Legacy hashes cannot be reversed; use their exact persisted
|
||
# dedup identity, never a display-name or another account.
|
||
prefix=self.account+':'
|
||
match=re.match(r'^(M:[0-9]+|S:[0-9]+_[0-9]+):',seen[len(prefix):]) if seen.startswith(prefix) else None
|
||
conv_id=match.group(1) if match else ''
|
||
if not contact_peer(self.account,conv_id) or session_key(self.account,conv_id)!=key:continue
|
||
if self._assistant_recipient(conv_id):continue
|
||
try:
|
||
context=self.db.get_conversation_context_by_id(self.account,conv_id,limit=500)
|
||
message=(context or {}).get('last_message') or {}
|
||
allowed,_,reason=self._contact_recheck(message,context,blocked)
|
||
if allowed:self._upsert(message,contact_recovery=True)
|
||
elif real_customer_event(message,self.account,conv_id):
|
||
self._contact_log(key,message.get('dedup_key'),f'{message.get("display_name") or conv_id} · {reason}')
|
||
except Exception as exc:
|
||
self._contact_log(key,seen,'受限会话暂不可核验，其他会话继续监听；'+type(exc).__name__)
|
||
|
||
def _skip_excluded_session(self,key,source,*,expected_state=None,reason=''):
|
||
reason=reason or _session_exclusion(source)
|
||
if not reason:return False
|
||
with self._lock:
|
||
state=self._pending.get(key)
|
||
if state is not None:
|
||
if state.get('account')!=self.account or _send_protection(state):return True
|
||
if expected_state is not None and state is not expected_state:return True
|
||
event=source.get('dedup_key') or (state or {}).get('dedup_key') or ''
|
||
changed=state is not None or (event and self._seen.get(key)!=event)
|
||
if not changed:return True
|
||
self._pending.pop(key,None)
|
||
if event:self._seen[key]=event
|
||
self._save()
|
||
self.log(f"[协议跳过] {source.get('display_name') or (state or {}).get('display_name','')} · {reason}")
|
||
return True
|
||
|
||
def _upsert(self,message,*,contact_recovery=False):
|
||
if message.get('account')!=self.account:return
|
||
key=session_key(self.account,message['conv_id']);event=message.get('dedup_key','')
|
||
# Neither new messages nor contact notices resolve an unknown send.
|
||
with self._lock:
|
||
old=self._pending.get(key)
|
||
if old and (old.get('cancel_requested') or old.get('stage') in ('cancelled','disabled','paused')):
|
||
return
|
||
if old and _send_protection(old):
|
||
# Message arrival is not a delivery receipt. Only the coordinator's
|
||
# exact new-human-message evidence may resolve a finished attempt.
|
||
self._register_assistant_review(key,old)
|
||
self._reconcile_assistant_review(key,old)
|
||
return
|
||
if self._assistant_recipient(message['conv_id']):
|
||
with self._lock:
|
||
self._pending.pop(key,None)
|
||
if event:self._seen[key]=event
|
||
self._save()
|
||
return
|
||
if old and self._assistant_attention(old):
|
||
from review_state import task_review_state
|
||
if task_review_state(old)['needsHuman'] and (old.get('assistant_review_id') or self._assistant_call('enabled')):
|
||
# Keep a manual task and its original watermark until an exact
|
||
# human reply resolves it. Additional customer messages must not
|
||
# replace the task with an automatically sendable text draft.
|
||
context=self.db.get_conversation_context_by_id(self.account,message['conv_id'],limit=500)
|
||
self._register_assistant_review(key,old,context)
|
||
if self._reconcile_assistant_review(key,old,context):return
|
||
with self._lock:
|
||
if self._pending.get(key) is old and event and not message.get('is_self'):
|
||
self._seen[key]=event;self._save()
|
||
return
|
||
if old and message.get('is_self'):
|
||
context=self.db.get_conversation_context_by_id(self.account,message['conv_id'],limit=500)
|
||
if self._reconcile_assistant_review(key,old,context):return
|
||
if self._assistant_pending(old):return
|
||
if self._skip_excluded_session(key,message):return
|
||
status=system_contact_status(message)
|
||
if status=='blocked':
|
||
self._skip_contact(key,message.get('display_name',''),event,source=message);return
|
||
with self._lock:
|
||
if status=='restored':
|
||
self._contact_blocked.pop(key,None)
|
||
self._seen[key]=event;self._save();return
|
||
blocked=self._contact_blocked.get(key)
|
||
retry_evidence=None
|
||
if blocked:
|
||
if message.get('is_self'):return
|
||
if old and self._assistant_attention(old):
|
||
self._contact_log(key,event,f'{message.get("display_name") or message["conv_id"]} · 原任务仍待人工处理，联系人重新核验不会批准原任务')
|
||
return
|
||
context=self.db.get_conversation_context_by_id(self.account,message['conv_id'],limit=500)
|
||
allowed,retry_evidence,reason=self._contact_recheck(message,context,blocked)
|
||
if not allowed:
|
||
self._contact_log(key,event,f'{message.get("display_name") or message["conv_id"]} · {reason}')
|
||
return
|
||
self._contact_log(key,event,f'{message.get("display_name") or message["conv_id"]} · 当前客户关系有效，对新的客户消息重新生成并风控；不重试旧回复')
|
||
with self._lock:
|
||
old=self._pending.get(key)
|
||
if old and _send_protection(old):return
|
||
if message.get('is_self'):
|
||
if old:self._pending.pop(key,None);self._save()
|
||
return
|
||
if not event or (self._seen.get(key)==event and not (contact_recovery and retry_evidence)):return
|
||
now=time.time();self._seen[key]=event
|
||
self._pending[key]={'transport':'protocol','account':self.account,'conv_id':message['conv_id'],'display_name':message.get('display_name') or message['conv_id'],
|
||
'dedup_key':event,'created_at':old.get('created_at',now) if old else now,'updated_at':now,'ready_at':now+self.message_batch_window_seconds,
|
||
'stage':'queued','stage_started_at':now,'send_state':'','chat_text':'','last_lines':[message.get('content','')],'staged_user_text':message.get('content',''),
|
||
'detected_by':'protocol_db','detection_ts':now,'reply_text':'','awaiting_review':False,'content_type':message.get('content_type'),
|
||
'database_event':dict(message),'assistant_resume_evidence':message.get('assistant_resume_evidence'),
|
||
'contact_retry_evidence':retry_evidence}
|
||
self._save()
|
||
self.log(f"[协议收信] {message.get('display_name') or message['conv_id']} · 已加入回复队列")
|
||
self._progress('协议已收到新消息 · 等待处理')
|
||
def _isolate_task_error(self,key,error,expected_state=None):
|
||
"""Keep a failed conversation out of automatic replay, without stopping peers."""
|
||
detail='本会话处理异常，其他会话继续监听'
|
||
stage='error'
|
||
with self._lock:
|
||
state=self._pending.get(key)
|
||
if state is not None and state.get('account')==self.account and (
|
||
expected_state is None or state is expected_state):
|
||
protection=_send_protection(state)
|
||
if protection in ('sending','uncertain'):
|
||
state['send_state']='uncertain';self.needs_attention=True
|
||
stage='receipt_check'
|
||
detail='本会话发送结果待人工核对，其他会话继续监听'
|
||
elif protection=='failed':
|
||
stage='failed'
|
||
try:self._stage(key,stage,detail,str(error))
|
||
except Exception:
|
||
# _stage updates memory before persisting. A storage/logging
|
||
# failure must not let this conversation send again in this run.
|
||
state.update(stage=stage,last_error=str(error),stage_detail=detail)
|
||
try:self.log(f'[协议会话异常] {detail}；{type(error).__name__}: {error}')
|
||
except Exception:pass
|
||
|
||
def poll_once(self):
|
||
if self.stop_event.is_set():return
|
||
try:self._flush_assistant_cancellations()
|
||
except Exception as exc:self._isolate_task_error(None,exc)
|
||
messages=self.db.get_new_messages(self._since)
|
||
# A malformed row/task belongs to one conversation, not the whole listener.
|
||
incoming=[]
|
||
for message in messages:
|
||
try:
|
||
if not isinstance(message,dict):raise ValueError('消息记录格式错误')
|
||
if message.get('account')!=self.account:continue
|
||
if not isinstance(message.get('conv_id'),str) or not message['conv_id']:
|
||
raise ValueError('消息缺少会话标识')
|
||
incoming.append((int(message.get('rowid',0)),message))
|
||
except Exception as exc:self._isolate_task_error(None,exc)
|
||
# Row order is authoritative even for late writes or equal timestamps.
|
||
for _,message in sorted(incoming,key=lambda item:item[0]):
|
||
if self.stop_event.is_set():return
|
||
key=session_key(self.account,message['conv_id'])
|
||
try:self._upsert(message)
|
||
except Exception as exc:self._isolate_task_error(key,exc)
|
||
self._recover_blocked_contacts()
|
||
def created_at(state):
|
||
try:return float(state.get('created_at',0) or 0)
|
||
except (TypeError,ValueError):return 0
|
||
with self._lock:tasks=sorted(self._pending.items(),key=lambda item:created_at(item[1]))
|
||
for key,state in tasks:
|
||
if self.stop_event.is_set():break
|
||
try:self._process(key)
|
||
except Exception as exc:self._isolate_task_error(key,exc,expected_state=state)
|
||
if self.stop_event.is_set():return
|
||
self._assistant_call('enqueue_notifications',default=None)
|
||
self._completed_polls+=1
|
||
self._listening_progress()
|
||
now=time.monotonic()
|
||
if now-self._last_poll_log>=60:
|
||
self._last_poll_log=now
|
||
with self._lock:pending=sum(s.get('account')==self.account for s in self._pending.values())
|
||
self.log(f'[协议监听] 消息库轮询正常；已检查 {self._completed_polls} 轮，待处理 {pending} 个会话，已确认发送 {self.reply_count} 条。')
|
||
def _current(self,key,state,*,excluded=None,before_dispatch=False):
|
||
with self._lock:
|
||
if self.stop_event.is_set() or self._pending.get(key) is not state:return False
|
||
if self._assistant_recipient(state['conv_id']):
|
||
if excluded is not None:excluded.append('配置的医疗助理会话不参与自动回复')
|
||
return False
|
||
if self._skip_excluded_session(key,state,expected_state=state):
|
||
if excluded is not None:excluded.append(_session_exclusion(state))
|
||
return False
|
||
context=self.db.get_conversation_context_by_id(self.account,state['conv_id'],limit=100)
|
||
context=self._assistant_context(state,context)
|
||
for source in (context or {},(context or {}).get('last_message') or {}):
|
||
if self._skip_excluded_session(key,source,expected_state=state):
|
||
if excluded is not None:excluded.append(_session_exclusion(source))
|
||
return False
|
||
if self._reconcile_assistant_review(key,state,context):return False
|
||
last=(context or {}).get('last_message')
|
||
if not last:return False
|
||
if last.get('is_self') and self._assistant_pending(state):return False
|
||
if last.get('is_self') or last.get('dedup_key')!=state['dedup_key']:
|
||
# A new customer message invalidates an earlier draft and its approval.
|
||
with self._lock:
|
||
if self._pending.get(key) is state and state.get('send_state')!='uncertain':
|
||
state['send_state']='';self._pending.pop(key,None)
|
||
self._seen.pop(key,None);self._save()
|
||
self._upsert(last);return False
|
||
blocked=self._contact_blocked.get(key) or state.get('contact_retry_evidence')
|
||
if blocked or conversation_contact_reason(context):
|
||
allowed,evidence,reason=self._contact_recheck(last,context,blocked,in_flight=before_dispatch and state.get('send_state')=='sending')
|
||
if not allowed:
|
||
self._skip_contact(key,state.get('display_name',''),state['dedup_key'],reason,context=context);return False
|
||
if state.get('contact_retry_evidence')!=evidence:
|
||
with self._lock:state['contact_retry_evidence']=evidence;self._save()
|
||
self._contact_log(key,state['dedup_key'],f'{state.get("display_name", "")} · 当前客户关系有效，对新的客户消息重新生成并风控；不重试旧回复')
|
||
context=self._contact_context(state,context)
|
||
voice_fingerprint=_voice_batch_fingerprint(context)
|
||
frozen_voice=state.get('voice_batch_fingerprint')
|
||
if ((frozen_voice and frozen_voice!=voice_fingerprint)
|
||
or (voice_fingerprint and state.get('reply_text') and not frozen_voice)):
|
||
with self._lock:
|
||
if self._pending.get(key) is not state:return False
|
||
protection=_send_protection(state)
|
||
# The explicit final sender guard runs before native dispatch.
|
||
# Never rewrite uncertain/failed delivery evidence on a cache change.
|
||
if protection and not (protection=='sending' and before_dispatch):return False
|
||
state.update(reply_text='',staged_reply_text='',approved=False,
|
||
judge_risk='',judge_mode='',model_task_id='',send_ready_at=0)
|
||
state.pop('voice_batch_fingerprint',None)
|
||
if not (state.get('manual_required') or state.get('cancel_requested')
|
||
or state.get('foreign_draft_text') or state.get('foreign_draft_at') is not None
|
||
or state.get('stage') in ('error','manual_takeover','cancelled','disabled','paused')):
|
||
now=time.time()
|
||
state.update(stage='queued',stage_detail='语音转文字内容已更新，等待重新生成回复',
|
||
stage_started_at=now,updated_at=now,ready_at=now)
|
||
# Keep independent manual/review flags. A new answer must pass the
|
||
# active review policy again; an approval never covers changed text.
|
||
self._save()
|
||
return False
|
||
return True
|
||
def _process(self,key):
|
||
with self._lock:state=self._pending.get(key)
|
||
if not state or state.get('account')!=self.account:return
|
||
if self._assistant_cancellation_pending(state) or state.get('cancel_requested') or state.get('stage') in ('cancelled','disabled','paused'):return
|
||
self._register_assistant_review(key,state)
|
||
if self._reconcile_assistant_review(key,state):return
|
||
if _send_protection(state):return
|
||
if self._assistant_recipient(state['conv_id']):
|
||
with self._lock:
|
||
if self._pending.get(key) is state:self._pending.pop(key,None);self._save()
|
||
return
|
||
if self._skip_excluded_session(key,state,expected_state=state):return
|
||
if state.get('stage') in ('error','manual_takeover'):return
|
||
if state.get('manual_required') or state.get('foreign_draft_text') or state.get('foreign_draft_at') is not None:return
|
||
if time.time()<float(state.get('ready_at',0)):return
|
||
if not self._current(key,state):return
|
||
# One extra row detects a current customer batch cut by the 100-message window.
|
||
context=self.db.get_conversation_context_by_id(self.account,state['conv_id'],limit=101)
|
||
context=self._assistant_context(state,context)
|
||
context=self._contact_context(state,context)
|
||
for source in (context or {},(context or {}).get('last_message') or {}):
|
||
if self._skip_excluded_session(key,source,expected_state=state):return
|
||
from voice_messages import voice_batch_status, unanswered_messages
|
||
voice = voice_batch_status(context)
|
||
manual_reason = ''
|
||
if voice['status'] == 'pending':
|
||
now = time.time()
|
||
with self._lock:
|
||
if state.get('voice_wait_key') != voice['key']:
|
||
state.update(voice_wait_key=voice['key'], voice_wait_started_at=now)
|
||
waited = now - float(state.get('voice_wait_started_at') or now)
|
||
if waited < 180:
|
||
state.update(ready_at=now+2, reply_text='', staged_reply_text='')
|
||
if waited < 180:
|
||
self._stage(key,'voice_transcribing',voice['reason']);return
|
||
manual_reason='语音转文字等待超时，尚未取得可核验文字，请人工处理'
|
||
elif voice['status'] == 'error':
|
||
manual_reason=voice['reason']
|
||
else:
|
||
state.pop('voice_wait_key',None);state.pop('voice_wait_started_at',None)
|
||
manual_reason=manual_reason or _unanswered_manual_reason(context)
|
||
current=(context or {}).get('last_message') or {}
|
||
if current.get('dedup_key')!=state.get('dedup_key') or not _is_text_message(current):
|
||
manual_reason=manual_reason or MANUAL_NON_TEXT_REASON
|
||
if not manual_reason:
|
||
# The current question/risk check and archive receive the same transcribed batch as the model.
|
||
batch=unanswered_messages(context)
|
||
state.update(staged_user_text='\n'.join(str(m.get('content') or '') for m in batch),
|
||
last_lines=[str(m.get('content') or '') for m in batch])
|
||
if manual_reason:
|
||
lines=[]
|
||
for message in reversed((context or {}).get('messages') or []):
|
||
if message.get('is_self') or system_contact_status(message)=='restored':break
|
||
lines.append(str(message.get('content') or '（非文本消息）'))
|
||
if len(lines)>=101:break
|
||
with self._lock:
|
||
state.update(reply_text='',staged_reply_text='',approved=False,awaiting_review=False,
|
||
review_reason='',manual_required=True,manual_reason=manual_reason,
|
||
chat_text=str((context or {}).get('text') or ''),last_lines=list(reversed(lines)))
|
||
self._stage(key,'error','当前消息需要人工处理',manual_reason);return
|
||
if not state.get('reply_text'):
|
||
with self._lock:state['voice_batch_fingerprint']=_voice_batch_fingerprint(context)
|
||
self._stage(key,'generating','根据当前会话生成回复')
|
||
try:
|
||
answer=self.generate(context)
|
||
if not isinstance(answer,str) or not answer.strip() or answer.strip().startswith(('__VISION_', '__NO_INCOMING_MESSAGE__', '__VOICE_NOT_TRANSCRIBED__')):raise ValueError('模型未返回有效文本')
|
||
except Exception as exc:self._stage(key,'error','模型生成失败，可重试',str(exc));return
|
||
if not self._current(key,state):return
|
||
with self._lock:
|
||
state.update(reply_text=answer.strip(),staged_reply_text=answer.strip(),chat_text=context['text'],send_ready_at=time.time()+self.send_delay_seconds)
|
||
self._save()
|
||
review,reason=self._needs_review(state)
|
||
if review and not state.get('approved'):
|
||
if not state.get('awaiting_review') or state.get('review_reason')!=reason:
|
||
with self._lock:state.update(awaiting_review=True,review_reason=reason,manual_required=False,manual_reason='')
|
||
self._stage(key,'awaiting_review',reason)
|
||
return
|
||
if not review and (state.get('awaiting_review') or state.get('review_reason')):
|
||
with self._lock:state.update(awaiting_review=False,review_reason='')
|
||
self._stage(key,'ready_to_send','审核策略已更新，等待发送前核对')
|
||
if time.time()<float(state.get('send_ready_at',0)):return
|
||
if not self._current(key,state):return
|
||
import send_lock
|
||
if not send_lock.try_acquire('protocol:'+str(threading.get_ident()),timeout=0):return
|
||
try:
|
||
if not self._current(key,state):return
|
||
self._send_ready(key,state)
|
||
finally:send_lock.release()
|
||
|
||
def _send_ready(self,key,state):
|
||
with self._lock:
|
||
if self._pending.get(key) is not state:return
|
||
state.update(send_state='sending',awaiting_review=False)
|
||
self._stage(key,'sending','原账号单聊发送')
|
||
guard_exclusions=[]
|
||
try:
|
||
receipt=self.sender.send(state['dedup_key'],self.pid,self.account,state['conv_id'],state['reply_text'],guard=lambda:self._current(key,state,excluded=guard_exclusions,before_dispatch=True))
|
||
except SendCancelled:
|
||
with self._lock:
|
||
if self._pending.get(key) is state:state.update(send_state='',stage='queued',stage_detail='发送前检查已取消，等待重新核对');self._save()
|
||
# SendCancelled proves the native call did not start. Only now may an
|
||
# exclusion discovered by the final sender guard remove this draft.
|
||
if guard_exclusions:self._skip_excluded_session(key,state,expected_state=state,reason=guard_exclusions[-1])
|
||
return
|
||
except DeliveryUnknown as exc:
|
||
# Keep the send journal's unknown outcome, but a proven contact restriction
|
||
# isolates this conversation instead of blocking all other customers.
|
||
try:context=self.db.get_conversation_context_by_id(self.account,state['conv_id'],limit=100)
|
||
except Exception:context=None
|
||
notice=latest_contact_notice(context)
|
||
if (notice and system_contact_status(notice)=='blocked'
|
||
and contact_event_order(notice)>contact_event_order(state.get('database_event') or {})):
|
||
self._skip_contact(key,state.get('display_name',''),state['dedup_key'],source=notice,rejected=True);return
|
||
with self._lock:state['send_state']='uncertain';self.needs_attention=True
|
||
self._stage(key,'receipt_check','本会话发送结果待人工核对，其他会话继续监听',str(exc));return
|
||
except DeliveryFailed as exc:
|
||
if rejected_contact_reason(str(exc)):
|
||
self._skip_contact(key,state.get('display_name',''),state['dedup_key'],str(exc),source=state.get('database_event'),rejected=True);return
|
||
with self._lock:state['send_state']='failed'
|
||
self._stage(key,'failed','客户端拒绝发送，需人工核对',str(exc));return
|
||
except NativeUnavailable as exc:
|
||
with self._lock:state['send_state']=''
|
||
self._stage(key,'error','发送前检查失败',str(exc));return
|
||
except Exception as exc:
|
||
# A callback or journal failure can escape after delivery. Do not
|
||
# turn an attempted send into a retryable task based on its type.
|
||
with self._lock:state['send_state']='uncertain';self.needs_attention=True
|
||
self._stage(key,'receipt_check','本会话发送结果待人工核对，其他会话继续监听',str(exc));return
|
||
self._assistant_call('record_automated_send',state,receipt,default=None)
|
||
self.reply_count+=1
|
||
self.log(f"[协议发送成功] {state['display_name']} · 服务器消息 {receipt['serverId']}")
|
||
try:
|
||
from conversation_store import ConversationStore
|
||
from queue_log import QueueLog
|
||
store=ConversationStore(str(application_data_dir()/'conversations.json'))
|
||
store.set_display_name(key,state['display_name'])
|
||
store.append_exchange_once(key,state['staged_user_text'],state['reply_text'],state['dedup_key'])
|
||
QueueLog().append(key,state['display_name'],'发送成功',f"协议回执 {receipt['serverId']}，原账号及文本已核对")
|
||
except Exception as exc:self.log('[协议归档] '+str(exc))
|
||
with self._lock:
|
||
if self._pending.get(key) is state:self._pending.pop(key,None)
|
||
if state.get('contact_retry_evidence'):self._contact_blocked.pop(key,None)
|
||
self._save()
|
||
def _needs_review(self,state):
|
||
import ai_config
|
||
from review_policy import selective_review_reason
|
||
reason=selective_review_reason(state,state.get('staged_user_text',''),state.get('reply_text',''),
|
||
rules=getattr(ai_config,'AI_REVIEW_RULES',[]) or [])
|
||
if reason:return True,reason
|
||
if self._assistant_pending(state):
|
||
return True,state.get('review_reason') or '本会话仍有待处理审核，请由医疗助理回复客户'
|
||
if self.send_mode=='review' and not self._assistant_call('resumed',state.get('conv_id','')):
|
||
return True,'人工审核后点击“通过并发送”'
|
||
return False,''
|
||
def _generate(self,context):
|
||
import ai_config,ai_chat,model_router,uuid
|
||
key=session_key(self.account,context['conv_id']);task_id=uuid.uuid4().hex
|
||
with self._lock:
|
||
generation_state=self._pending.get(key)
|
||
if generation_state is not None:
|
||
generation_state.update(model_task_id=task_id,judge_risk='',judge_mode='')
|
||
if not ai_config.AI_ENABLED:return self.reply_text
|
||
context={**context,'text':model_context_text(context)}
|
||
if ai_chat.gateway_provider() is not None:
|
||
ai_chat.take_last_gateway_trace()
|
||
reply=ai_chat.get_ai_reply(chat_text=context['text'])
|
||
trace=ai_chat.take_last_gateway_trace()
|
||
key=session_key(self.account,context['conv_id'])
|
||
with self._lock:
|
||
if self._pending.get(key) is generation_state and generation_state is not None and generation_state.get('model_task_id')==task_id:
|
||
self._pending[key]['judge_risk']=str((trace.get('judge') or {}).get('risk') or '')
|
||
self._pending[key]['judge_mode']=str(trace.get('judge_mode') or '').strip().lower()
|
||
self._pending[key]['knowledge_trace']=trace.get('knowledge') or {}
|
||
self._pending[key]['model_task_id']=trace.get('task_id') or ''
|
||
return reply
|
||
provider=ai_chat.current_provider();judge=provider if getattr(ai_config,'AI_JUDGE_ENABLED',False) else None
|
||
if judge is None:return ai_chat.get_ai_reply(chat_text=context['text'])
|
||
from voice_messages import unanswered_messages
|
||
customer_text='\n'.join(str(message.get('content') or '') for message in unanswered_messages(context))
|
||
result=model_router.answer(chat_text=context['text'],answer_providers=[provider],judge_provider=judge,judge_mode=getattr(ai_config,'AI_JUDGE_MODE','shadow'),customer_text=customer_text)
|
||
key=session_key(self.account,context['conv_id'])
|
||
with self._lock:
|
||
if self._pending.get(key) is generation_state and generation_state is not None and generation_state.get('model_task_id')==task_id:
|
||
generation_state.update(judge_risk=str((result.get('judge') or {}).get('risk') or ''),
|
||
judge_mode=str(result.get('judge_mode') or '').strip().lower())
|
||
return result.get('reply','')
|
||
def _control(self,keys,action):
|
||
removed=[]
|
||
result={'deleted':[],'retried':[],'approved':[],'missing':[],'protected':[],'not_retryable':[],'not_pending':[],'scheduled':[]}
|
||
with self._lock:
|
||
previous_pending=dict(self._pending);previous_cancellations=dict(self._assistant_cancellations)
|
||
for key in keys:
|
||
s=self._pending.get(key)
|
||
if s is None:result['missing'].append(key);continue
|
||
if s.get('account')!=self.account:result['protected'].append(key);continue
|
||
if _send_protection(s):result['protected'].append(key);continue
|
||
if action=='delete':
|
||
self._queue_assistant_cancellation(s)
|
||
self._pending.pop(key,None);result['deleted'].append(key);removed.append(s)
|
||
elif action=='approve':
|
||
if s.get('awaiting_review') and s.get('reply_text') and not s.get('manual_required'):
|
||
now=time.time()
|
||
s.update(approved=True,awaiting_review=False,review_reason='',stage='ready_to_send',
|
||
stage_detail='审核已通过，等待发送前核对',stage_started_at=now,updated_at=now)
|
||
result['approved'].append(key)
|
||
else:result['not_pending'].append(key)
|
||
elif action=='retry':
|
||
if s.get('stage')=='error':
|
||
now=time.time()
|
||
s.update(stage='queued',stage_detail='等待重新处理',stage_started_at=now,updated_at=now,
|
||
last_error='',ready_at=now,reply_text='',staged_reply_text='',approved=False,
|
||
awaiting_review=False,review_reason='',manual_required=False,manual_reason='',
|
||
judge_risk='',judge_mode='',model_task_id='')
|
||
result['retried'].append(key)
|
||
else:result['not_retryable'].append(key)
|
||
try:self._save()
|
||
except Exception:
|
||
if action=='delete':
|
||
self._pending=previous_pending;self._assistant_cancellations=previous_cancellations
|
||
raise
|
||
self._reply_wakeup.set()
|
||
self._flush_assistant_cancellations()
|
||
for state in removed:
|
||
if not state.get('assistant_review_id'):self._assistant_call('cancel_review',state)
|
||
return result
|
||
def handoff_pending_replies(self, keys, *, confirm_uncertain=False):
|
||
"""Explicitly retire selected work to a human without claiming delivery.
|
||
|
||
Uncertain receipts remain in the send journal and the inbound dedup key
|
||
stays seen. No send/retry is scheduled by this action.
|
||
"""
|
||
result={'handed_off':[], 'deleted':[], 'missing':[], 'protected':[], 'scheduled':[], 'requires_confirmation':[]}
|
||
removed=[]
|
||
with self._lock:
|
||
previous_pending=dict(self._pending);previous_seen=dict(self._seen)
|
||
previous_handoffs=dict(self._manual_handoffs);previous_attention=self.needs_attention
|
||
previous_cancellations=dict(self._assistant_cancellations)
|
||
for key in dict.fromkeys(str(k).strip() for k in keys if str(k).strip()):
|
||
state=self._pending.get(key)
|
||
if state is None:result['missing'].append(key);continue
|
||
protection=_send_protection(state)
|
||
if state.get('account')!=self.account or protection=='sending':
|
||
result['protected'].append(key);continue
|
||
if protection=='uncertain' and not confirm_uncertain:
|
||
result['protected'].append(key);result['requires_confirmation'].append(key);continue
|
||
snapshot=json.loads(json.dumps(state,ensure_ascii=False))
|
||
self._manual_handoffs[key]={'state':snapshot,'handed_off_at':time.time(),
|
||
'receipt_checked_by_user':bool(confirm_uncertain),
|
||
'delivery_confirmed':False}
|
||
if state.get('dedup_key'):self._seen[key]=state['dedup_key']
|
||
self._queue_assistant_cancellation(state)
|
||
self._pending.pop(key,None)
|
||
result['handed_off'].append(key);result['deleted'].append(key)
|
||
removed.append((key,state))
|
||
self.needs_attention=any(s.get('account')==self.account and _send_protection(s)=='uncertain'
|
||
for s in self._pending.values())
|
||
try:self._save()
|
||
except Exception:
|
||
self._pending=previous_pending;self._seen=previous_seen
|
||
self._manual_handoffs=previous_handoffs;self.needs_attention=previous_attention
|
||
self._assistant_cancellations=previous_cancellations
|
||
raise
|
||
self._reply_wakeup.set()
|
||
self._flush_assistant_cancellations()
|
||
for key,state in removed:
|
||
if not state.get('assistant_review_id'):self._assistant_call('cancel_review',state)
|
||
self.log(f"[协议转人工] {state.get('display_name','')} · 自动队列已移交人工；发送结果未作确认，不自动重发")
|
||
try:
|
||
from queue_log import QueueLog
|
||
QueueLog().append(key,state.get('display_name',''),'转人工',
|
||
'用户已确认人工接管；保留发送流水和去重记录，不自动重发')
|
||
except Exception:pass
|
||
self._listening_progress()
|
||
return result
|
||
|
||
def cancel_pending_replies(self,keys):return self._control(keys,'delete')
|
||
def retry_pending_replies(self,keys):return self._control(keys,'retry')
|
||
def approve_pending_replies(self,keys):return self._control(keys,'approve')
|
||
def close(self):
|
||
if self._review_assistant is not None:
|
||
try:self._review_assistant.close()
|
||
except Exception:pass
|
||
self.sender.close()
|
||
if self._owned_db:self.db.close() |