246 lines
8.0 KiB
Python
246 lines
8.0 KiB
Python
from asgiref.sync import sync_to_async
|
|
from django.conf import settings
|
|
|
|
from core.messaging.utils import messages_to_string
|
|
from core.models import ChatSession, Message, QueuedMessage
|
|
from core.util import logs
|
|
|
|
log = logs.get_logger("history")
|
|
|
|
# Prompt-window controls:
|
|
# - Full message history is always persisted in the database.
|
|
# - Only the prompt input window is reduced.
|
|
# - Max values are hard safety rails; runtime chooses a smaller adaptive subset.
|
|
# - Min value prevents overly aggressive clipping on very long average messages.
|
|
DEFAULT_PROMPT_HISTORY_MAX_MESSAGES = getattr(
|
|
settings, "PROMPT_HISTORY_MAX_MESSAGES", 120
|
|
)
|
|
DEFAULT_PROMPT_HISTORY_MAX_CHARS = getattr(
|
|
settings,
|
|
"PROMPT_HISTORY_MAX_CHARS",
|
|
24000,
|
|
)
|
|
DEFAULT_PROMPT_HISTORY_MIN_MESSAGES = getattr(
|
|
settings, "PROMPT_HISTORY_MIN_MESSAGES", 24
|
|
)
|
|
|
|
|
|
def _build_recent_history(messages, max_chars):
|
|
"""
|
|
Build the final prompt transcript under a strict character budget.
|
|
|
|
Method:
|
|
1. Iterate messages from newest to oldest so recency is prioritized.
|
|
2. For each message, estimate the rendered line length exactly as it will
|
|
appear in the prompt transcript.
|
|
3. Stop once adding another line would exceed `max_chars`, while still
|
|
guaranteeing at least one message can be included.
|
|
4. Reverse back to chronological order for readability in prompts.
|
|
"""
|
|
if not messages:
|
|
return ""
|
|
|
|
selected = []
|
|
total_chars = 0
|
|
# Recency-first packing, then reorder to chronological output later.
|
|
for msg in reversed(messages):
|
|
author = msg.custom_author or msg.session.identifier.person.name
|
|
line = f"[{msg.ts}] <{author}> {msg.text}"
|
|
line_len = len(line) + 1
|
|
# Keep at least one line even if it alone exceeds max_chars.
|
|
if selected and (total_chars + line_len) > max_chars:
|
|
break
|
|
selected.append(msg)
|
|
total_chars += line_len
|
|
|
|
selected.reverse()
|
|
return messages_to_string(selected)
|
|
|
|
|
|
def _compute_adaptive_message_limit(messages, max_messages, max_chars):
|
|
"""
|
|
Derive how many messages to include before final char-budget packing.
|
|
|
|
This function intentionally avoids hand-picked threshold buckets.
|
|
Instead, it computes a budget-derived estimate:
|
|
- Build a recent sample (up to 80 messages) representing current chat style.
|
|
- Measure *rendered* line lengths (timestamp + author + text), not raw text.
|
|
- Estimate average line length from that sample.
|
|
- Convert char budget into message budget: floor(max_chars / avg_line_len).
|
|
- Clamp to configured min/max rails.
|
|
|
|
Why two stages:
|
|
- Stage A (this function): estimate count from current message density.
|
|
- Stage B (`_build_recent_history`): enforce exact char ceiling.
|
|
This keeps behavior stable while guaranteeing hard prompt budget compliance.
|
|
"""
|
|
if not messages:
|
|
return DEFAULT_PROMPT_HISTORY_MIN_MESSAGES
|
|
|
|
sample = messages[-min(len(messages), 80) :]
|
|
rendered_lengths = []
|
|
for msg in sample:
|
|
author = (
|
|
msg.custom_author
|
|
if msg.custom_author
|
|
else msg.session.identifier.person.name
|
|
)
|
|
text = msg.text or ""
|
|
# Match the line shape used in _build_recent_history/messages_to_string.
|
|
rendered_lengths.append(len(f"[{msg.ts}] <{author}> {text}") + 1)
|
|
|
|
# Defensive denominator: never divide by zero.
|
|
avg_line_len = (
|
|
(sum(rendered_lengths) / len(rendered_lengths)) if rendered_lengths else 1.0
|
|
)
|
|
avg_line_len = max(avg_line_len, 1.0)
|
|
|
|
budget_based = int(max_chars / avg_line_len)
|
|
adaptive = max(DEFAULT_PROMPT_HISTORY_MIN_MESSAGES, budget_based)
|
|
adaptive = min(max_messages, adaptive)
|
|
return max(1, adaptive)
|
|
|
|
|
|
async def get_chat_history(
|
|
session,
|
|
max_messages=DEFAULT_PROMPT_HISTORY_MAX_MESSAGES,
|
|
max_chars=DEFAULT_PROMPT_HISTORY_MAX_CHARS,
|
|
):
|
|
"""
|
|
Return prompt-ready chat history with adaptive windowing and hard budget limits.
|
|
|
|
Pipeline:
|
|
1. Fetch a bounded recent slice from DB (performance guard).
|
|
2. Estimate adaptive message count from observed rendered message density.
|
|
3. Keep only the newest `adaptive_limit` messages.
|
|
4. Pack those lines under `max_chars` exactly.
|
|
"""
|
|
# Storage remains complete; only prompt context is reduced.
|
|
fetch_limit = max(max_messages * 3, 200)
|
|
fetch_limit = min(fetch_limit, 1000)
|
|
stored_messages = await sync_to_async(list)(
|
|
Message.objects.filter(session=session, user=session.user).order_by("-ts")[
|
|
:fetch_limit
|
|
]
|
|
)
|
|
stored_messages.reverse()
|
|
adaptive_limit = _compute_adaptive_message_limit(
|
|
stored_messages,
|
|
max_messages=max_messages,
|
|
max_chars=max_chars,
|
|
)
|
|
selected_messages = stored_messages[-adaptive_limit:]
|
|
recent_chat_history = _build_recent_history(selected_messages, max_chars=max_chars)
|
|
chat_history = f"Recent Messages:\n{recent_chat_history}"
|
|
|
|
return chat_history
|
|
|
|
|
|
async def get_chat_session(user, identifier):
|
|
chat_session, _ = await sync_to_async(ChatSession.objects.get_or_create)(
|
|
identifier=identifier,
|
|
user=user,
|
|
)
|
|
return chat_session
|
|
|
|
|
|
async def store_message(session, sender, text, ts, outgoing=False):
|
|
log.debug("Storing message for session=%s outgoing=%s", session.id, outgoing)
|
|
msg = await sync_to_async(Message.objects.create)(
|
|
user=session.user,
|
|
session=session,
|
|
sender_uuid=sender,
|
|
text=text,
|
|
ts=ts,
|
|
delivered_ts=ts,
|
|
custom_author="USER" if outgoing else None,
|
|
)
|
|
|
|
return msg
|
|
|
|
|
|
async def store_own_message(session, text, ts, manip=None, queue=False):
|
|
log.debug("Storing own message for session=%s queue=%s", session.id, queue)
|
|
cast = {
|
|
"user": session.user,
|
|
"session": session,
|
|
"custom_author": "BOT",
|
|
"text": text,
|
|
"ts": ts,
|
|
"delivered_ts": ts,
|
|
}
|
|
if queue:
|
|
msg_object = QueuedMessage
|
|
cast["manipulation"] = manip
|
|
else:
|
|
msg_object = Message
|
|
|
|
msg = await sync_to_async(msg_object.objects.create)(
|
|
**cast,
|
|
)
|
|
|
|
return msg
|
|
|
|
|
|
async def delete_queryset(queryset):
|
|
await sync_to_async(queryset.delete, thread_sensitive=True)()
|
|
|
|
|
|
async def apply_read_receipts(
|
|
user,
|
|
identifier,
|
|
message_timestamps,
|
|
read_ts=None,
|
|
source_service="signal",
|
|
read_by_identifier="",
|
|
payload=None,
|
|
):
|
|
"""
|
|
Persist delivery/read metadata for one identifier's messages.
|
|
"""
|
|
ts_values = []
|
|
for item in message_timestamps or []:
|
|
try:
|
|
ts_values.append(int(item))
|
|
except Exception:
|
|
continue
|
|
if not ts_values:
|
|
return 0
|
|
|
|
try:
|
|
read_at = int(read_ts) if read_ts else None
|
|
except Exception:
|
|
read_at = None
|
|
|
|
rows = await sync_to_async(list)(
|
|
Message.objects.filter(
|
|
user=user,
|
|
session__identifier=identifier,
|
|
ts__in=ts_values,
|
|
).select_related("session")
|
|
)
|
|
updated = 0
|
|
for message in rows:
|
|
dirty = []
|
|
if message.delivered_ts is None:
|
|
message.delivered_ts = read_at or message.ts
|
|
dirty.append("delivered_ts")
|
|
if read_at and (message.read_ts is None or read_at > message.read_ts):
|
|
message.read_ts = read_at
|
|
dirty.append("read_ts")
|
|
if source_service and message.read_source_service != source_service:
|
|
message.read_source_service = source_service
|
|
dirty.append("read_source_service")
|
|
if read_by_identifier and message.read_by_identifier != read_by_identifier:
|
|
message.read_by_identifier = read_by_identifier
|
|
dirty.append("read_by_identifier")
|
|
if payload:
|
|
receipt_data = dict(message.receipt_payload or {})
|
|
receipt_data[str(source_service)] = payload
|
|
message.receipt_payload = receipt_data
|
|
dirty.append("receipt_payload")
|
|
if dirty:
|
|
await sync_to_async(message.save)(update_fields=dirty)
|
|
updated += 1
|
|
return updated
|