Adjust backend content-type guidance

Author: owenisas

backend/lambda_handler.py

@@ -2998,7 +2998,9 @@ def handle_chat(event):
     auth_user = _get_authenticated_user(event)
 
     question = body.get("question")
-    if not question:
+    requested_content_types = body.get("requested_content_types") or []
+    has_files = bool(body.get("files") or body.get("prepared_upload_ids") or body.get("attachments"))
+    if not question and not requested_content_types and not has_files:
         return create_response(400, {"error": "Missing 'question' field"})
     if isinstance(question, str) and len(question) > _MAX_QUESTION_CHARS:
         return create_response(400, {"error": f"Question too long (max {_MAX_QUESTION_CHARS} characters)"})
@@ -3206,8 +3208,12 @@ def handle_continue(event):
     question = body.get("question")
     if not question and component_edit.get("instruction"):
         question = component_edit.get("instruction")
-    if not question:
+    
+    requested_content_types = body.get("requested_content_types") or []
+    has_files = bool(body.get("files") or body.get("prepared_upload_ids") or body.get("attachments"))
+    if not question and not requested_content_types and not has_files:
         return create_response(400, {"error": "Missing 'question' field"})
+    
     if isinstance(question, str) and len(question) > _MAX_QUESTION_CHARS:
         return create_response(400, {"error": f"Question too long (max {_MAX_QUESTION_CHARS} characters)"})
     attachments = _normalize_text_attachments(body.get("attachments"))
@@ -6159,19 +6165,73 @@ def process_async_job(event):
     # user-visible/persisted user_message content).
     content_type_system_message = None
     _CONTENT_TYPE_FORMAT_HINTS = {
-        "quiz": "quiz -> use `create_main_block` with `quiz_questions` array (multiple_choice or true_false)",
-        "flashcards": "flashcards -> use `create_main_block` with `flashcards` array ({front, back, variant})",
-        "images": "images -> call `search_brave_images` or `search_wiki_images` inline",
-        "animation": "animation -> call `generate_math_animation` for math/physics/CS concepts",
-        "youtube": "youtube embed -> use `create_main_block` with `youtube_urls` array",
-        "tables": "tables -> include markdown tables (| col1 | col2 |) in your content",
-        "graphs": "graphs/charts -> include a markdown table with quantitative data AND append a chart tag on the next line (<<bar>>, <<pie>>, <<line>>, <<scatter>>, <<area>>, etc.)",
-        "code": "code -> include fenced code blocks with language tags (```python, ```javascript, etc.)",
-        "equations": "equations -> include LaTeX math: $inline$ or $$display$$ blocks",
-        "quote": "quote -> include blockquotes using > prefix",
-        "definition": "definition -> use blockquote format: > **Definition: Term** — explanation",
-        "translation": "translation -> use `create_main_block` with `translations` array ({original, translated, language})",
+        "quiz": "quiz -> when you have enough context to answer, use `create_main_block` with `quiz_questions` array (multiple_choice or true_false)",
+        "flashcards": "flashcards -> when you have enough context to answer, use `create_main_block` with `flashcards` array ({front, back, variant})",
+        "images": "images -> when the topic is specific enough, call `search_brave_images` or `search_wiki_images` inline",
+        "animation": "animation -> when the concept is specific enough, call `generate_math_animation` for math/physics/CS concepts",
+        "youtube": "youtube embed -> when you have enough context to answer, use `create_main_block` with `youtube_urls` array",
+        "tables": "tables -> when you have enough context to answer, include markdown tables (| col1 | col2 |) in your content",
+        "graphs": "graphs/charts -> when you have enough context to answer, include a markdown table with quantitative data AND append a chart tag on the next line (<<bar>>, <<pie>>, <<line>>, <<scatter>>, <<area>>, etc.)",
+        "code": "code -> when you have enough context to answer, include fenced code blocks with language tags (```python, ```javascript, etc.)",
+        "equations": "equations -> when you have enough context to answer, include LaTeX math: $inline$ or $$display$$ blocks",
+        "quote": "quote -> when you have enough context to answer, include blockquotes using > prefix",
+        "definition": "definition -> when you have enough context to answer, use blockquote format: > **Definition: Term** — explanation",
+        "translation": "translation -> when you have enough context to answer, use `create_main_block` with `translations` array ({original, translated, language})",
+    }
+    _CONTENT_TYPE_LABELS = {
+        "quiz": "Quiz",
+        "flashcards": "Flashcards",
+        "images": "Images",
+        "animation": "Animation Engine",
+        "youtube": "YouTube Embed",
+        "tables": "Tables",
+        "graphs": "Graphs",
+        "code": "Code",
+        "equations": "Equations",
+        "quote": "Quote",
+        "definition": "Definition",
+        "translation": "Translation",
+        "social-embed": "Social Post Embed (X)",
+        "diagram": "Diagram",
+        "simulation": "2D/3D Simulation",
     }
+
+    # Auto-prompt generation (moved from frontend)
+    if not (user_message or "").strip() and requested_content_types and isinstance(requested_content_types, list):
+        labels = []
+        for t in requested_content_types:
+            t_str = str(t).strip()
+            if not t_str:
+                continue
+            
+            # Handle parent:variant
+            if ":" in t_str:
+                parentId = t_str.split(":")[0]
+                # Try to use the parent label as a reasonable fallback for variant
+                label = _CONTENT_TYPE_LABELS.get(parentId, parentId.capitalize())
+            else:
+                label = _CONTENT_TYPE_LABELS.get(t_str, t_str.capitalize())
+            
+            if label:
+                labels.append(label.lower())
+        
+        if labels:
+            # Deduplicate labels (in case multiple variants of same parent are selected)
+            unique_labels = []
+            for l in labels:
+                if l not in unique_labels:
+                    unique_labels.append(l)
+            
+            if len(unique_labels) == 1:
+                joined = unique_labels[0]
+            else:
+                joined = ", ".join(unique_labels[:-1]) + " and " + unique_labels[-1]
+            
+            if topic_name:
+                user_message = f"Generate {joined} about \"{topic_name}\"."
+            else:
+                user_message = f"Generate {joined} based on what we've covered so far."
+
     if requested_content_types and isinstance(requested_content_types, list):
         hints = []
         plain_names = []
@@ -6186,10 +6246,14 @@ def process_async_job(event):
         types_str = ", ".join(plain_names)
         format_block = "\n".join(hints) if hints else ""
         content_type_system_message = (
-            "The user has specifically requested the following content types: "
-            f"{types_str}.\n"
-            "You MUST include these in your answer.\n"
-            "Format guidance:\n"
+            "The user has specifically requested the following content types as preferred output modes "
+            f"for the eventual answer: {types_str}.\n"
+            "Treat these as preferences, not as reasons to skip clarification.\n"
+            "If the topic is underspecified or context is insufficient, ask one concise clarification question first "
+            "and DO NOT force tool calls, images, animation, or structured content yet.\n"
+            "Once you have enough context to answer well, satisfy the requested content types that are appropriate "
+            "and well-supported for the topic.\n"
+            "Format guidance for the eventual answer:\n"
             f"{format_block}"
         )
 

backend/tests/test_block_generation.py

@@ -705,6 +705,49 @@ def fake_run_agent_with_session(**kwargs):
     assert "cache coherency" in str(saved_block.metadata.get("parent_context_summary") or "")
 
 
+def test_process_async_job_content_type_guidance_defers_until_context_is_sufficient():
+    from lambda_handler import process_async_job
+    from models import Block, Session
+
+    session = Session()
+
+    event = {
+        "job_id": "job-content-types-1",
+        "session_id": session.id,
+        "user_message": "Generate images and animation",
+        "model": "test-model",
+        "requested_content_types": ["images", "animation"],
+    }
+
+    def fake_run_agent_with_session(**kwargs):
+        return Block(content="Please clarify which process you want visualized.")
+
+    with patch("lambda_handler.get_jobs_table") as mock_get_table, patch(
+        "lambda_handler.session_store"
+    ) as mock_store, patch("lambda_handler.run_agent_with_session") as mock_run:
+        mock_table = MagicMock()
+        mock_table.get_item.return_value = {
+            "Item": {
+                "id": "job-content-types-1",
+                "status": "PENDING",
+                "created_at": "2026-02-09T12:00:00Z",
+            }
+        }
+        mock_get_table.return_value = mock_table
+        mock_store.get.return_value = session
+        mock_store.save.return_value = None
+        mock_store.items_table = None
+        mock_store.table = None
+        mock_run.side_effect = fake_run_agent_with_session
+
+        process_async_job(event)
+
+    extra_system_message = mock_run.call_args.kwargs.get("extra_system_message", "")
+    assert "Treat these as preferences, not as reasons to skip clarification." in extra_system_message
+    assert "DO NOT force tool calls, images, animation, or structured content yet." in extra_system_message
+    assert "Once you have enough context to answer well" in extra_system_message
+
+
 def test_process_async_job_component_edit_appends_edit_prompt_and_metadata():
     from lambda_handler import process_async_job
     from models import Block, Session

backend/tests/test_lambda_handler.py

@@ -1334,6 +1334,33 @@ def test_chat_web_search_flag_forwarded_to_async_job():
     assert mock_create_async_job.call_args.kwargs["web_search"] is True
 
 
+def test_chat_accepts_content_types_without_question():
+    event = {
+        "httpMethod": "POST",
+        "path": "/chat",
+        "body": json.dumps({
+            "question": "",
+            "requested_content_types": ["images", "animation"],
+        }),
+    }
+
+    with patch("lambda_handler.session_store") as mock_session_store, patch(
+        "lambda_handler.create_async_job"
+    ) as mock_create_async_job:
+        mock_session = MagicMock()
+        mock_session.is_hidden = False
+        mock_session.id = "session-1"
+        mock_session_store.create.return_value = mock_session
+        mock_create_async_job.return_value = "job-1"
+
+        response = handler(event, None)
+
+    assert response["statusCode"] == 202
+    kwargs = mock_create_async_job.call_args.kwargs
+    assert kwargs["user_message"] == ""
+    assert kwargs["requested_content_types"] == ["images", "animation"]
+
+
 def test_is_allowed_model_accepts_gemini_models():
     assert lambda_handler._is_allowed_model("gemini-3.1-pro-preview") is True
     assert lambda_handler._is_allowed_model("gemini-3-flash-preview") is True

backend/tests/test_math_anim_integration.py

@@ -0,0 +1,36 @@
+import pytest
+import os
+import tempfile
+from math_anim import render_animation, is_safe_manim_code, generate_manim_code
+
+def mock_generate_manim(*args, **kwargs):
+    return \"\"\"
+from manim import *
+class SafeScene(Scene):
+    def construct(self):
+        text = Text("Hello AST!")
+        self.play(Write(text))
+        self.wait(1)
+\"\"\"
+
+def mock_generate_manim_unsafe(*args, **kwargs):
+    return \"\"\"
+import os
+from manim import *
+class UnsafeScene(Scene):
+    def construct(self):
+        os.system("echo 'pwned'")
+\"\"\"
+
+def test_safe_integration(monkeypatch):
+    monkeypatch.setattr("math_anim.generate_manim_code", mock_generate_manim)
+    code = generate_manim_code("test topic")
+    is_safe, msg = is_safe_manim_code(code)
+    assert is_safe
+    
+def test_unsafe_integration(monkeypatch):
+    monkeypatch.setattr("math_anim.generate_manim_code", mock_generate_manim_unsafe)
+    code = generate_manim_code("test topic")
+    is_safe, msg = is_safe_manim_code(code)
+    assert not is_safe
+    assert "not allowed" in msg

backend/tests/test_math_anim_security.py

@@ -0,0 +1,66 @@
+import pytest
+from math_anim import is_safe_manim_code
+
+def test_safe_manim_code():
+    code = \"\"\"
+from manim import *
+
+class TestScene(Scene):
+    def construct(self):
+        circle = Circle()
+        self.play(Create(circle))
+        self.wait(1)
+\"\"\"
+    is_safe, msg = is_safe_manim_code(code)
+    assert is_safe, f"Valid code should be safe. Failed with: {msg}"
+
+def test_unsafe_import():
+    code = \"\"\"
+import os
+import subprocess
+from manim import *
+
+class TestScene(Scene):
+    def construct(self):
+        os.system('ls')
+\"\"\"
+    is_safe, msg = is_safe_manim_code(code)
+    assert not is_safe
+    assert "not allowed" in msg
+
+def test_unsafe_builtin():
+    code = \"\"\"
+from manim import *
+open('/etc/passwd', 'r').read()
+
+class TestScene(Scene):
+    def construct(self):
+        circle = Circle()
+\"\"\"
+    is_safe, msg = is_safe_manim_code(code)
+    assert not is_safe
+    assert "dangerous builtin" in msg
+    assert "open" in msg
+
+def test_unsafe_eval():
+    code = \"\"\"
+from manim import *
+eval('print("hello")')
+\"\"\"
+    is_safe, msg = is_safe_manim_code(code)
+    assert not is_safe
+    assert "dangerous builtin" in msg
+    assert "eval" in msg
+
+def test_unsafe_dunder_attribute():
+    code = \"\"\"
+from manim import *
+
+class TestScene(Scene):
+    def construct(self):
+        cls = "".__class__.__mro__[1].__subclasses__()
+\"\"\"
+    is_safe, msg = is_safe_manim_code(code)
+    assert not is_safe
+    assert "dangerous attribute" in msg
+    assert "__class__" in msg or "__mro__" in msg or "__subclasses__" in msg

frontend/public/onboarding/tutorial-1.webm

@@ -17,7 +17,7 @@ import { usePreparedAttachments } from "@/hooks/usePreparedAttachments"
 import { useAuth } from "@/context/AuthContext"
 import ContentTypePicker, { InlineContentChips, type ContentTypePickerKeyHandler } from "@/components/ui/ContentTypePicker"
 import { readStoredModel, writeStoredModel } from "@/lib/models"
-import { readStoredContentTypes, writeStoredContentTypes, buildContentTypeAutoPrompt } from "@/lib/contentTypes"
+import { readStoredContentTypes, writeStoredContentTypes } from "@/lib/contentTypes"
 
 /* ═══════════════════════════════════════════════════════════
  *  ChatInput — memoized input component with typewriter,
@@ -150,9 +150,8 @@ const ChatInput = memo(function ChatInput() {
     if (!content && attachments.length === 0 && !hasContentTypes) return
     if (!canSend) return
 
-    // Auto-generate prompt when user selected content types but typed nothing
-    const messageText = content
-      || (hasContentTypes ? buildContentTypeAutoPrompt(inputFeatures.requestedContentTypes!) : "See attached files.")
+    // Auto-generate prompt when user selected content types but typed nothing (now handled by backend)
+    const messageText = content || ""
     const msgAttachments = attachments.length > 0 ? attachedToMessageFormat(attachments) : undefined
     const previousInputValue = inputValue
     const previousAttachments = attachments
@@ -164,7 +163,8 @@ const ChatInput = memo(function ChatInput() {
       if (activeView.startsWith("chat-")) {
         conversationId = activeView.replace("chat-", "")
       } else {
-        const created = addConversation(getConversationTitle(messageText))
+        const titleText = messageText || (hasContentTypes ? "New Content Request" : "New Session")
+        const created = addConversation(getConversationTitle(titleText))
         conversationId = created.id
         createdConversationId = created.id
       }