Require explicit image_prompt on all outgoing messages (jaredlockhart#795)

* Require explicit image_prompt on all send_response calls

Every outgoing message must now provide a short image search query
(max 100 chars). Removes the auto-image fallback that sent full message
content to Serper (causing 400 errors on long messages).

Image prompt sources by path:
- Chat messages: search query from tool calls, fallback to user message
- Notifications: first bold headline from response, fallback to answer text
- Check-ins: configurable CHECKIN_IMAGE_PROMPT
- News: first headline, fallback to "latest news"
- Scheduled tasks: search query from tool calls, fallback to prompt text

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* Use preference topic as image prompt for thought notifications

Look up the seed preference content (e.g., "shadowrun", "tube pedals")
via preference_id FK on the thought. Falls back to first headline or
answer text if no preference is linked. Also adds get_by_id to
PreferenceStore.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

* Test image prompts for all notification paths

Assert on the actual Serper query for each notification type:
- Thought candidates: preference topic ("quantum computing")
- News: first bold headline ("AI Breakthrough")
- Check-in: config param ("funny cat meme")
- Chat messages: model's search query ("test search query")

All assertions verify the query is short and matches the expected source.
Also seeds test thoughts with preference_id FK for proper preference lookup.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

---------

Co-authored-by: Jared Lockhart <119884+jaredlockhart@users.noreply.github.com>
Co-authored-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: 3 people

penny/penny/agents/notify.py

@@ -40,7 +40,7 @@ class NotifyCandidate(BaseModel):
     answer: str
     thought: Thought | None = None
     attachments: list[str] = Field(default_factory=list)
-    image_prompt: str | None = None
+    image_prompt: str
 
 
 class NotifyAgent(Agent):
@@ -208,7 +208,7 @@ async def _send_news(self, user: str) -> bool:
         answer = response.answer.strip() if response.answer else None
         if not answer:
             return False
-        image_prompt = self._extract_first_headline(answer)
+        image_prompt = self._extract_first_headline(answer) or "latest news"
         return await self._send_candidate(
             user,
             NotifyCandidate(
@@ -337,13 +337,20 @@ async def _generate_one_candidate(
         if self._is_disqualified(answer):
             logger.info("Disqualified candidate: %s", answer[:60])
             return None
-        image_prompt = self._extract_first_headline(answer)
+        image_prompt = self._seed_topic_for(thought) or answer[:50]
         return NotifyCandidate(
             answer=answer,
             thought=thought,
             image_prompt=image_prompt,
         )
 
+    def _seed_topic_for(self, thought: Thought | None) -> str | None:
+        """Look up the seed preference content for a thought."""
+        if not thought or not thought.preference_id:
+            return None
+        pref = self.db.preferences.get_by_id(thought.preference_id)
+        return pref.content if pref else None
+
     @classmethod
     def _is_disqualified(cls, answer: str) -> bool:
         """Check if a candidate is an error fallback or model refusal."""
@@ -438,9 +445,9 @@ async def _send_candidate(self, user: str, candidate: NotifyCandidate) -> bool:
             user,
             candidate.answer,
             parent_id=None,
+            image_prompt=candidate.image_prompt,
             attachments=candidate.attachments or None,
             quote_message=None,
-            image_prompt=candidate.image_prompt,
             thought_id=thought_id,
         )
         if candidate.thought and candidate.thought.id is not None:

penny/penny/channels/base.py

@@ -224,36 +224,44 @@ async def send_status_message(self, recipient: str, content: str) -> bool:
         )
         return external_id is not None
 
+    MAX_IMAGE_PROMPT_LENGTH = 100
+
     async def send_response(
         self,
         recipient: str,
         content: str,
         parent_id: int | None,
+        image_prompt: str,
         attachments: list[str] | None = None,
         quote_message: MessageLog | None = None,
-        image_prompt: str | None = None,
         thought_id: int | None = None,
     ) -> int | None:
         """
-        Log and send an outgoing message.
+        Log and send an outgoing message with an image attachment.
 
         Args:
             recipient: Identifier for the recipient
             content: Message content
             parent_id: Parent message ID for thread linking
+            image_prompt: Short search query for image attachment (max 100 chars)
             attachments: Optional list of base64-encoded attachments
             quote_message: Optional message to quote-reply to
-            image_prompt: Optional search query to find and attach an image
             thought_id: Optional FK to the thought that triggered this message
 
         Returns:
             Database message ID if send was successful, None otherwise
         """
-        if image_prompt:
-            attachments = await self._resolve_image(image_prompt, attachments)
+        if len(image_prompt) > self.MAX_IMAGE_PROMPT_LENGTH:
+            logger.error(
+                "image_prompt too long (%d chars, max %d): %s",
+                len(image_prompt),
+                self.MAX_IMAGE_PROMPT_LENGTH,
+                image_prompt[:100],
+            )
+            image_prompt = image_prompt[: self.MAX_IMAGE_PROMPT_LENGTH]
 
-        if not attachments and self._should_auto_image():
-            attachments = await self._resolve_image(content, attachments)
+        if not attachments:
+            attachments = await self._resolve_image(image_prompt, attachments)
 
         # Apply channel-specific formatting
         # We log the prepared content so quote matching works correctly
@@ -273,10 +281,20 @@ async def send_response(
         logger.info("Sent response to %s (%d chars)", recipient, len(content))
         return message_id if external_id is not None else None
 
-    def _should_auto_image(self) -> bool:
-        """Whether to auto-search for images on messages without attachments."""
-        serper_key = self._config.serper_api_key if self._config else None
-        return bool(serper_key)
+    @staticmethod
+    def _extract_image_prompt(response) -> str | None:
+        """Extract a short image search query from the agent's tool calls."""
+        for tc in response.tool_calls or []:
+            if tc.tool != "search":
+                continue
+            # Prefer single query, fall back to first of queries list
+            query = tc.arguments.get("query")
+            if query:
+                return query
+            queries = tc.arguments.get("queries")
+            if queries:
+                return queries[0]
+        return None
 
     async def _resolve_image(
         self, image_prompt: str, attachments: list[str] | None
@@ -424,6 +442,7 @@ async def _dispatch_to_agent(self, message: IncomingMessage) -> None:
             )
 
             answer = response.answer.strip() if response.answer else PennyResponse.FALLBACK_RESPONSE
+            image_prompt = self._extract_image_prompt(response) or message.content[:100]
             incoming_log = MessageLog(
                 id=incoming_id,
                 direction=PennyConstants.MessageDirection.INCOMING,
@@ -435,6 +454,7 @@ async def _dispatch_to_agent(self, message: IncomingMessage) -> None:
                 message.sender,
                 answer,
                 parent_id=incoming_id,
+                image_prompt=image_prompt,
                 attachments=response.attachments or None,
                 quote_message=incoming_log,
             )

penny/penny/database/preference_store.py

@@ -51,6 +51,11 @@ def add(
             logger.error("Failed to add preference: %s", e)
             return None
 
+    def get_by_id(self, pref_id: int) -> Preference | None:
+        """Get a single preference by ID."""
+        with self._session() as session:
+            return session.get(Preference, pref_id)
+
     def get_for_user(self, user: str, limit: int = 100) -> list[Preference]:
         """Get all preferences for a user, newest first."""
         with self._session() as session:

penny/penny/scheduler/schedule_runner.py

@@ -105,10 +105,12 @@ async def _execute_scheduled_prompt(self, schedule: Schedule) -> None:
             return
 
         # Send the response to the user
+        image_prompt = self._channel._extract_image_prompt(response) or schedule.prompt_text[:100]
         await self._channel.send_response(
             schedule.user_id,
             answer,
-            parent_id=None,  # Scheduled prompts are not threaded
+            parent_id=None,
+            image_prompt=image_prompt,
             attachments=response.attachments or None,
             quote_message=None,
         )

penny/penny/tests/agents/test_message.py

@@ -149,8 +149,11 @@ async def test_basic_message_flow(
         ]
         assert len(conversation_echoes) == 0, "Conversation echo thoughts should not be logged"
 
-        # Serper image search should have been called for the outgoing message
+        # Serper image search should use the model's search query, not full content
         mock_serper_image.assert_called_once()
+        image_query = mock_serper_image.call_args[0][0]
+        assert image_query == "test search query"
+        assert len(image_query) <= 100
 
         # Outgoing message should have an image attachment
         assert response.get("base64_attachments"), "Response should include an image attachment"

penny/penny/tests/agents/test_notify.py

@@ -4,16 +4,28 @@
 
 import pytest
 
+from penny.agents.notify import NotifyAgent
 from penny.constants import PennyConstants
 from penny.tests.conftest import TEST_SENDER, wait_until
 
 
 def _seed_notify(penny):
-    """Seed data needed for notifications: message, history, thought."""
+    """Seed data needed for notifications: message, preference, thought."""
     penny.db.messages.log_message(
         PennyConstants.MessageDirection.INCOMING, TEST_SENDER, "hello penny"
     )
-    penny.db.thoughts.add(TEST_SENDER, "I've been thinking about quantum computing")
+    pref = penny.db.preferences.add(
+        user=TEST_SENDER,
+        content="quantum computing",
+        valence="positive",
+        source_period_start=datetime(2026, 3, 20),
+        source_period_end=datetime(2026, 3, 20),
+    )
+    penny.db.thoughts.add(
+        TEST_SENDER,
+        "I've been thinking about quantum computing",
+        preference_id=pref.id if pref else None,
+    )
 
 
 # ── Eligibility checks ──────────────────────────────────────────────────
@@ -128,8 +140,10 @@ def handler(request, count):
         unnotified = penny.db.thoughts.get_next_unnotified(TEST_SENDER)
         assert unnotified is None
 
-        # Serper image search should have been called
+        # Serper image search should have been called with the preference topic
         mock_serper_image.assert_called_once()
+        image_query = mock_serper_image.call_args[0][0]
+        assert "quantum computing" in image_query.lower()
         assert response.get("base64_attachments"), "Notification should include an image"
 
 
@@ -142,16 +156,17 @@ async def test_send_notify_news(
     test_user_info,
     running_penny,
     monkeypatch,
+    mock_serper_image,
 ):
-    """News mode generates and sends a news message."""
-    config = make_config()
+    """News mode generates and sends a news message with image."""
+    config = make_config(serper_api_key="test-key")
 
     # Force news path (not checkin)
     monkeypatch.setattr("penny.agents.notify.random.random", lambda: 0.0)
 
     def handler(request, count):
         return mock_ollama._make_text_response(
-            request, "interesting news today about AI breakthroughs!"
+            request, "interesting news: **AI Breakthrough** changes everything!"
         )
 
     mock_ollama.set_response_handler(handler)
@@ -165,7 +180,13 @@ def handler(request, count):
 
         await wait_until(lambda: len(signal_server.outgoing_messages) > 0)
         response = signal_server.outgoing_messages[-1]
-        assert response["message"]  # Non-empty response sent
+        assert response["message"]
+
+        # Image search should use the first bold headline
+        mock_serper_image.assert_called_once()
+        image_query = mock_serper_image.call_args[0][0]
+        assert image_query == "AI Breakthrough"
+        assert response.get("base64_attachments"), "News should include an image"
 
 
 @pytest.mark.asyncio
@@ -177,9 +198,10 @@ async def test_send_notify_checkin(
     test_user_info,
     running_penny,
     monkeypatch,
+    mock_serper_image,
 ):
-    """Check-in sends a message when conditions are met."""
-    config = make_config()
+    """Check-in sends a message with cat meme image."""
+    config = make_config(serper_api_key="test-key")
 
     def handler(request, count):
         return mock_ollama._make_text_response(request, "hey! what have you been up to?")
@@ -197,6 +219,12 @@ def handler(request, count):
         response = signal_server.outgoing_messages[-1]
         assert response["message"]
 
+        # Image search should use the check-in image prompt config
+        mock_serper_image.assert_called_once()
+        image_query = mock_serper_image.call_args[0][0]
+        assert image_query == "funny cat meme"
+        assert response.get("base64_attachments"), "Check-in should include an image"
+
 
 # ── Image prompt extraction ──────────────────────────────────────────────
 
@@ -359,7 +387,3 @@ def test_is_disqualified_allows_normal_messages():
     """Normal conversational messages are not disqualified."""
     assert not NotifyAgent._is_disqualified("Hey! Been thinking about quantum computing.")
     assert not NotifyAgent._is_disqualified("Check out this cool new game!")
-
-
-# Need to import NotifyAgent for static method tests
-from penny.agents.notify import NotifyAgent  # noqa: E402