fix: route format price questions to catalog and stop inventing formats

app/services/intent.py

@@ -99,6 +99,10 @@ _PRICE_INQUIRY_SIGNALS: tuple[str, ...] = (
     "are those hardcover", "are these hardcover",
     "are those audiobook", "are these audiobook",
     "are those ebook", "are these ebook",
+    "audiobook price", "audiobook prices", "audio book", "audio-book",
+    "ebook price", "ebook prices", "e-book price",
+    "hardcover price", "hardcover prices", "paperback price", "paperback prices",
+    "what about audio", "what about ebook", "what about hardcover",
 )
 
 _PURCHASE_SIGNALS: tuple[str, ...] = (

app/services/pipeline/core.py

@@ -228,22 +228,7 @@ async def run_pipeline(
         )
 
     # ── Step 2: Intent Classification ─────────────────────────────────────────
-    _t_intent = time.monotonic()
     intent_result = await classify_intent(query, session_context.history)
-    # #region agent log
-    from app.debug_agent_log import agent_dbg
-
-    agent_dbg(
-        "L3",
-        "core.py:intent",
-        "intent step timing",
-        {
-            "ms": int((time.monotonic() - _t_intent) * 1000),
-            "source": intent_result.source,
-            "intent": intent_result.intent,
-        },
-    )
-    # #endregion
     log.debug("Intent classified", intent=intent_result.intent, source=intent_result.source)
 
     if intent_result.intent == "jailbreak_attempt":
@@ -318,10 +303,14 @@ async def run_pipeline(
     # ── Price intelligence short-circuit (after book resolve; skip RAG/LLM) ──
     from app.services.price_catalog_service import PriceCatalogService, classify_price_query
 
-    price_kind = classify_price_query(query).kind
+    price_q = classify_price_query(query)
+    price_kind = price_q.kind
     use_price_catalog = search_book_id and (
         intent_result.intent == "price_inquiry"
-        or (intent_result.intent == "purchase_intent" and price_kind == "how_much")
+        or (
+            intent_result.intent == "purchase_intent"
+            and price_kind == "how_much"
+        )
     )
     if use_price_catalog and price_kind != "soft_value":
         book_title = selected_book_title(active_books, search_book_id) or "this book"
@@ -336,27 +325,6 @@ async def run_pipeline(
             link_shown=bool(price_result.get("has_links") or price_result.get("platform_offers")),
         )
 
-    # #region agent log
-    from app.debug_agent_log import agent_dbg
-
-    agent_dbg(
-        "H1-H3",
-        "core.py:search_book",
-        "pipeline book resolution",
-        {
-            "query": (query or "")[:160],
-            "selected_book_id": session_context.selected_book_id,
-            "target_book_id": target_book_id,
-            "search_book_id": search_book_id,
-            "book_reference": getattr(intent_result, "book_reference", None),
-            "book_confidence": getattr(intent_result, "book_confidence", None),
-            "cross_book_search": cross_book_search,
-            "history_len": len(session_context.history or []),
-            "active_titles": [(b.id[:8], (b.title or "")[:40]) for b in active_books[:8]],
-        },
-    )
-    # #endregion
-
     # ── Objection Detection (persuasion modifier, never blocks) ──────────────
     objection_type = detect_objection(query)
     prior_objections = (
@@ -402,46 +370,24 @@ async def run_pipeline(
             )
 
     # ── Step 4: Query Rewriting ───────────────────────────────────────────────
-    _t_rewrite = time.monotonic()
     query_variations = await rewrite_query(query, session_context.history)
 
     # ── Step 5: Vector Retrieval ──────────────────────────────────────────────
-    _t_retrieve = time.monotonic()
     raw_chunks = await retrieve_chunks(
         queries=query_variations,
         author_id=author.id,
         book_id=search_book_id,
         top_k=cfg.RAG_RETRIEVAL_TOP_K,
     )
-    # #region agent log
-    from app.debug_agent_log import agent_dbg
-
-    agent_dbg(
-        "L4",
-        "core.py:retrieve_timing",
-        "rewrite+retrieve timing",
-        {
-            "rewrite_ms": int((_t_retrieve - _t_rewrite) * 1000),
-            "retrieve_ms": int((time.monotonic() - _t_retrieve) * 1000),
-            "search_book_id": search_book_id,
-            "chunk_count": len(raw_chunks or []),
-            "chunk_book_ids": list({c.book_id for c in (raw_chunks or [])})[:6],
-            "chunk_titles": list({(c.book_title or "")[:50] for c in (raw_chunks or [])})[:6],
-            "variations0": (query_variations[0][:120] if query_variations else None),
-        },
-    )
-    # #endregion
     if not raw_chunks:
         log.warning("No chunks retrieved")
         return await no_context_response(query, author, active_books, session_context, db, start_ms)
 
     # ── Step 6: Re-ranking ────────────────────────────────────────────────────
-    _t_rerank = time.monotonic()
     top_chunks = await rerank_chunks(
         query=query, chunks=raw_chunks,
         top_n=cfg.RAG_RERANK_TOP_N, min_score=cfg.RAG_RERANK_MIN_SCORE,
     )
-    _rerank_ms = int((time.monotonic() - _t_rerank) * 1000)
     if not top_chunks:
         top_chunks = raw_chunks[: cfg.RAG_RERANK_TOP_N]
     if not top_chunks:
@@ -467,7 +413,6 @@ async def run_pipeline(
         strategy = _upsell_engine.select_strategy(effective_int, upsell_ctx)
 
     # ── Steps 8–10: LLM Generation + Faithfulness + Safety ───────────────────
-    _t_gen = time.monotonic()
     price_facts = ""
     if objection_type == "price" and search_book_id:
         try:
@@ -498,19 +443,6 @@ async def run_pipeline(
             price_facts=price_facts,
         )
     )
-    # #region agent log
-    agent_dbg(
-        "L1-L2",
-        "core.py:gen_timing",
-        "rerank+generate+faithfulness timing",
-        {
-            "rerank_ms": _rerank_ms,
-            "gen_faith_ms": int((time.monotonic() - _t_gen) * 1000),
-            "total_ms": int((time.monotonic() - start_ms) * 1000),
-            "faithfulness_score": faithfulness_score,
-        },
-    )
-    # #endregion
 
     top_book_ids = list({c.book_id for c in top_chunks})
 

app/services/price_catalog_service.py

@@ -14,7 +14,7 @@ from typing import Any
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from app.repositories.platform_listing_repo import PlatformListingRepository
-from app.services.book_url_scraper import PLATFORM_DISPLAY
+from app.services.book_url_scraper import PLATFORM_DISPLAY, _normalize_retail_format_label
 from app.services.platform_catalog import (
     BOT_CHAT_EXCLUDED_PLATFORMS,
     canonical_format_prices,
@@ -54,6 +54,9 @@ _FORMAT_HINTS: tuple[tuple[str, str], ...] = (
     ("e-book", "eBook"),
     ("kindle", "eBook"),
     ("audiobook", "Audiobook"),
+    ("audio book", "Audiobook"),
+    ("audio-book", "Audiobook"),
+    ("audio prices", "Audiobook"),
     ("audible", "Audiobook"),
 )
 
@@ -171,6 +174,12 @@ def classify_price_query(message: str) -> PriceQuery:
     )):
         return PriceQuery(kind="how_much", platform_ids=platforms, format_hint=fmt)
 
+    # Format-named price questions: "what about audio book prices", "ebook price"
+    if fmt and any(s in q for s in (
+        "price", "prices", "cost", "costs", "how much", "what about",
+    )):
+        return PriceQuery(kind="how_much", platform_ids=platforms, format_hint=fmt)
+
     return PriceQuery(kind="none", platform_ids=platforms, format_hint=fmt)
 
 
@@ -261,8 +270,23 @@ class PriceCatalogService:
                 continue
 
             list_price = (getattr(row, "list_price", None) or "").strip()
+            raw_bf = (getattr(row, "book_format", None) or "").strip()
+            labeled = _normalize_retail_format_label(raw_bf) if raw_bf else ""
+            if labeled and labeled not in _FORMAT_ORDER:
+                labeled = ""
             if format_hint:
-                # No format map — cannot claim the hint; skip this row.
+                # Only claim this format when book_format matches the hint.
+                if labeled != format_hint or not list_price:
+                    continue
+                offers.append(Offer(
+                    platform_id=pid,
+                    platform=display_name,
+                    price_display=list_price,
+                    price_cents=parse_price_cents(list_price),
+                    url=url,
+                    is_source=is_source,
+                    format=labeled,
+                ))
                 continue
             offers.append(Offer(
                 platform_id=pid,
@@ -271,7 +295,7 @@ class PriceCatalogService:
                 price_cents=parse_price_cents(list_price),
                 url=url,
                 is_source=is_source,
-                format="",
+                format=labeled,
             ))
         return offers
 
@@ -290,6 +314,10 @@ class PriceCatalogService:
             author_id, book_id, format_hint=hint,
         )
         if not offers:
+            if hint:
+                return await self._build_missing_format_answer(
+                    author_id, book_id, book_title, hint,
+                )
             return await self._build_empty_fallback(author_id, book_id, book_title)
 
         kind = pq.kind
@@ -309,6 +337,36 @@ class PriceCatalogService:
             return self._build_how_much_answer(offers, book_title, pq.platform_ids)
         return self._build_list_answer(offers, book_title)
 
+    async def _build_missing_format_answer(
+        self,
+        author_id: str,
+        book_id: str,
+        book_title: str,
+        format_hint: str,
+    ) -> dict[str, Any]:
+        """Honest reply when a named format has no stored prices; show what is stored."""
+        available = await self.catalog_for_book(author_id, book_id, format_hint="")
+        formats = sorted({o.format for o in available if o.format})
+        if formats:
+            named = ", ".join(formats)
+            text = (
+                f"I don't have {format_hint} prices stored for {book_title} yet. "
+                f"On file I have: {named}. Pick a Buy button for those."
+            )
+        else:
+            text = (
+                f"I don't have {format_hint} prices stored for {book_title} yet. "
+                "I only list formats I have on file — nothing invented."
+            )
+        return {
+            "text": text[:380],
+            "links": [],
+            "has_links": False,
+            "platform_offers": [
+                offer_to_platform_item(o) for o in available
+            ] if available else None,
+        }
+
     async def _build_empty_fallback(
         self, author_id: str, book_id: str, book_title: str,
     ) -> dict[str, Any]:
@@ -331,10 +389,16 @@ class PriceCatalogService:
     def _build_list_answer(self, offers: list[Offer], book_title: str) -> dict[str, Any]:
         """All verified platform+format rows as platform_offers grid."""
         priced = sum(1 for o in offers if o.price_cents is not None)
+        has_formats = any(o.format for o in offers)
+        if has_formats:
+            detail = f"{priced} with a listed price and format"
+        else:
+            detail = f"{priced} with a listed price"
         text = (
             f"Here are the places I know for {book_title} — "
-            f"{priced} with a listed price and format. "
-            "Pick a Buy button for the store and format you prefer."
+            f"{detail}. "
+            "Pick a Buy button for the store"
+            + (" and format you prefer." if has_formats else " you prefer.")
         )
         return {
             "text": text,

tests/unit/test_price_catalog_service.py

@@ -36,6 +36,10 @@ def test_classify_price_query_kinds():
     assert classify_price_query("are those hardcover or audiobook").kind == "format_clarify"
     assert classify_price_query("which format is the $35").kind == "format_clarify"
     assert classify_price_query("cheapest ebook").format_hint == "eBook"
+    audio = classify_price_query("what about audio book prices")
+    assert audio.kind == "how_much"
+    assert audio.format_hint == "Audiobook"
+    assert classify_price_query("audio book").format_hint == "Audiobook"
 
 
 def test_price_inquiry_intent_before_purchase():
@@ -44,6 +48,7 @@ def test_price_inquiry_intent_before_purchase():
     assert _classify_by_rules("where is it cheapest") == "price_inquiry"
     assert _classify_by_rules("list all platforms") == "price_inquiry"
     assert _classify_by_rules("are those hardcover or audiobook") == "price_inquiry"
+    assert _classify_by_rules("what about audio book prices") == "price_inquiry"
     assert _classify_by_rules("how much does it cost") == "purchase_intent"
 
 
@@ -280,3 +285,59 @@ async def test_handle_format_clarify():
     assert result["platform_offers"] is not None
     assert any(o["format"] == "Hardcover" for o in result["platform_offers"])
     assert "invent" in result["text"].lower() or "format" in result["text"].lower()
+
+
+@pytest.mark.asyncio
+async def test_list_answer_omits_and_format_when_empty():
+    svc = PriceCatalogService.__new__(PriceCatalogService)
+    offers = [
+        Offer("amazon", "Amazon", "$35.00", 3500, "https://a.com", True, ""),
+        Offer("apple_books", "Apple Books", "$14.99", 1499, "https://apple.com", False, ""),
+    ]
+    result = svc._build_list_answer(offers, "All We Say")
+    assert "and format" not in result["text"]
+    assert "listed price" in result["text"]
+
+
+@pytest.mark.asyncio
+async def test_missing_audiobook_is_honest_and_shows_available():
+    svc = PriceCatalogService(MagicMock())
+
+    async def _catalog(_a, _b, *, format_hint=""):
+        if format_hint == "Audiobook":
+            return []
+        return [
+            Offer("amazon", "Amazon", "$35.00", 3500, "https://a.com", True, "Hardcover"),
+            Offer("apple_books", "Apple Books", "$14.99", 1499, "https://apple.com", False, "eBook"),
+        ]
+
+    svc.catalog_for_book = _catalog
+    result = await svc.handle(
+        "what about audio book prices", "a1", "b1", "All We Say",
+    )
+    assert "Audiobook" in result["text"]
+    assert "don't have" in result["text"].lower() or "do not have" in result["text"].lower()
+    assert result["platform_offers"] is not None
+    assert any(o["format"] == "eBook" for o in result["platform_offers"])
+    assert "Buy Book" not in (result.get("links") or [])
+
+
+@pytest.mark.asyncio
+async def test_catalog_uses_book_format_when_no_format_prices():
+    svc = PriceCatalogService(MagicMock())
+    svc._listings = MagicMock()
+    svc._listings.list_for_book = AsyncMock(return_value=[
+        SimpleNamespace(
+            status="verified",
+            listing_url="https://amazon.com/dp/B0X",
+            platform_id="amazon",
+            format_prices={},
+            list_price="$35.00",
+            book_format="Hardcover",
+            is_source=True,
+        ),
+    ])
+    offers = await svc.catalog_for_book("a1", "b1")
+    assert len(offers) == 1
+    assert offers[0].format == "Hardcover"
+    assert offers[0].price_display == "$35.00"