Implement AI workspace and mitigation workflow

core/messaging/history.py

@@ -1,19 +1,136 @@
-from core.util import logs
-from core.models import Message, ChatSession, QueuedMessage
 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")
 
-async def get_chat_history(session):
-    stored_messages = await sync_to_async(list)(
-        Message.objects.filter(session=session, user=session.user).order_by("ts")
+# 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):
+        line = f"[{msg.ts}] <{msg.custom_author if msg.custom_author else msg.session.identifier.person.name}> {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
     )
-    recent_chat_history = messages_to_string(stored_messages)
-    chat_history = f"Chat Summary:\n{session.summary}\n\nRecent Messages:\n{recent_chat_history}" if session.summary else f"Recent Messages:\n{recent_chat_history}"
+    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,
@@ -21,6 +138,7 @@ async def get_chat_session(user, identifier):
     )
     return chat_session
 
+
 async def store_message(session, sender, text, ts, outgoing=False):
     log.info(f"STORE MESSAGE {text}")
     msg = await sync_to_async(Message.objects.create)(
@@ -29,11 +147,12 @@ async def store_message(session, sender, text, ts, outgoing=False):
         sender_uuid=sender,
         text=text,
         ts=ts,
-        custom_author="USER" if outgoing else None
+        custom_author="USER" if outgoing else None,
     )
 
     return msg
 
+
 async def store_own_message(session, text, ts, manip=None, queue=False):
     log.info(f"STORE OWN MESSAGE {text}")
     cast = {
@@ -53,4 +172,8 @@ async def store_own_message(session, text, ts, manip=None, queue=False):
         **cast,
     )
 
-    return msg
+    return msg
+
+
+async def delete_queryset(queryset):
+    await sync_to_async(queryset.delete, thread_sensitive=True)()