databricks-tellr-app 0.4.3.dev3462__tar.gz → 0.4.3.dev3463__tar.gz

{databricks_tellr_app-0.4.3.dev3462 → databricks_tellr_app-0.4.3.dev3463}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: databricks-tellr-app
-Version: 0.4.3.dev3462
+Version: 0.4.3.dev3463
 Summary: Tellr application package for Databricks Apps
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown

{databricks_tellr_app-0.4.3.dev3462 → databricks_tellr_app-0.4.3.dev3463}/databricks_tellr_app/run.py

@@ -68,23 +68,6 @@ def init_database(seed_databricks_defaults: bool = False) -> None:
         logger.error(f"Failed to bootstrap Graph Configuration: {e}\n{tb}")
         raise SystemExit(1) from e
 
-    logger.info("Backfilling Conversation Pins...")
-    try:
-        from src.core.database import get_session_local
-        from src.services.conversation_pins import backfill_conversation_pins
-
-        result = backfill_conversation_pins(get_session_local())
-        logger.info(
-            "Conversation Pins ready: release_id=%s version=%s pinned=%s",
-            result.graph_release_id,
-            result.graph_version,
-            result.pinned_count,
-        )
-    except Exception as e:
-        tb = traceback.format_exc()
-        logger.error(f"Failed to backfill Conversation Pins: {e}\n{tb}")
-        raise SystemExit(1) from e
-
     # Data migrations/backfills that used to run in the FastAPI lifespan now run
     # HERE, once, before the server forks its workers — the uvicorn workers must
     # never execute migration code (4 of them racing the migration chain on boot

{databricks_tellr_app-0.4.3.dev3462 → databricks_tellr_app-0.4.3.dev3463}/databricks_tellr_app.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: databricks-tellr-app
-Version: 0.4.3.dev3462
+Version: 0.4.3.dev3463
 Summary: Tellr application package for Databricks Apps
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown

{databricks_tellr_app-0.4.3.dev3462 → databricks_tellr_app-0.4.3.dev3463}/databricks_tellr_app.egg-info/SOURCES.txt

@@ -62,7 +62,6 @@ setup.py
 ./src/api/services/session_manager.py
 ./src/api/services/session_naming.py
 ./src/api/services/slide_repository.py
-./src/api/services/slide_style_preview_queue.py
 ./src/api/services/usage_events.py
 ./src/api/services/usage_service.py
 ./src/api/utils/__init__.py
@@ -118,7 +117,6 @@ setup.py
 ./src/database/models/session.py
 ./src/database/models/slide_deck_prompt.py
 ./src/database/models/slide_style_library.py
-./src/database/models/slide_style_preview.py
 ./src/database/models/usage_event.py
 ./src/database/models/user_preference.py
 ./src/domain/__init__.py
@@ -185,8 +183,6 @@ setup.py
 ./src/services/profile_service.py
 ./src/services/prompt_assembler.py
 ./src/services/shared_deck_attribution.py
-./src/services/slide_style_preview_fixture.py
-./src/services/slide_style_preview_storage.py
 ./src/services/spec_sync.py
 ./src/services/streaming_callback.py
 ./src/services/svg_sanitizer.py
@@ -301,7 +297,6 @@ src/api/services/job_queue.py
 src/api/services/session_manager.py
 src/api/services/session_naming.py
 src/api/services/slide_repository.py
-src/api/services/slide_style_preview_queue.py
 src/api/services/usage_events.py
 src/api/services/usage_service.py
 src/api/utils/__init__.py
@@ -357,7 +352,6 @@ src/database/models/request_log.py
 src/database/models/session.py
 src/database/models/slide_deck_prompt.py
 src/database/models/slide_style_library.py
-src/database/models/slide_style_preview.py
 src/database/models/usage_event.py
 src/database/models/user_preference.py
 src/domain/__init__.py
@@ -424,8 +418,6 @@ src/services/pptx_prompts_defaults.py
 src/services/profile_service.py
 src/services/prompt_assembler.py
 src/services/shared_deck_attribution.py
-src/services/slide_style_preview_fixture.py
-src/services/slide_style_preview_storage.py
 src/services/spec_sync.py
 src/services/streaming_callback.py
 src/services/svg_sanitizer.py

{databricks_tellr_app-0.4.3.dev3462 → databricks_tellr_app-0.4.3.dev3463}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "databricks-tellr-app"
-version = "0.4.3.dev3462"
+version = "0.4.3.dev3463"
 description = "Tellr application package for Databricks Apps"
 readme = "README.md"
 requires-python = ">=3.10"

{databricks_tellr_app-0.4.3.dev3462 → databricks_tellr_app-0.4.3.dev3463}/src/api/main.py

@@ -49,7 +49,6 @@ from src.api.services.export_job_queue import (
     start_export_worker,
 )
 from src.api.services.job_queue import recover_stuck_requests, start_worker
-from src.api.services.slide_style_preview_queue import start_preview_worker
 from src.core.database import (
     is_lakebase_environment,
     start_token_refresh,
@@ -71,7 +70,6 @@ IS_TESTING = ENVIRONMENT == "test"
 _worker_task = None
 _export_worker_task = None
 _export_cleanup_task: asyncio.Task | None = None
-_preview_worker_task = None
 _cleanup_task = None
 _timeout_task = None
 _spec_sweeper_task = None
@@ -81,7 +79,7 @@ _frontend_assets_stack: ExitStack | None = None
 @asynccontextmanager
 async def lifespan(app: FastAPI):
     """Lifespan context manager for startup/shutdown events."""
-    global _worker_task, _export_worker_task, _export_cleanup_task, _preview_worker_task
+    global _worker_task, _export_worker_task, _export_cleanup_task
     global _cleanup_task, _timeout_task, _spec_sweeper_task, _frontend_assets_stack
 
     # Startup
@@ -153,20 +151,6 @@ async def lifespan(app: FastAPI):
         _export_cleanup_task = await start_export_cleanup_worker()
         logger.info("Export job cleanup worker started")
 
-        # Start the slide-style preview generation worker
-        _preview_worker_task = await start_preview_worker()
-        logger.info("Slide-style preview worker started")
-
-        # Pre-warm previews for active styles so viewers hit a warm cache instead
-        # of a cold LLM generation. Bounded + deduplicated; runs off the event loop.
-        try:
-            from src.api.services.slide_style_preview_queue import warm_missing_previews
-
-            warmed = await asyncio.to_thread(warm_missing_previews)
-            logger.info("Slide-style preview warm backfill enqueued", extra={"enqueued": warmed})
-        except Exception:  # noqa: BLE001 — warming must never block startup
-            logger.warning("Slide-style preview warm backfill failed", exc_info=True)
-
         # Start the MCP job timeout sweeper
         from src.api.services.job_queue import mark_timed_out_jobs_loop
         _timeout_task = asyncio.create_task(mark_timed_out_jobs_loop())
@@ -230,14 +214,6 @@ async def lifespan(app: FastAPI):
             pass
         logger.info("Export job cleanup worker stopped")
 
-    if _preview_worker_task:
-        _preview_worker_task.cancel()
-        try:
-            await _preview_worker_task
-        except asyncio.CancelledError:
-            pass
-        logger.info("Slide-style preview worker stopped")
-
     if _cleanup_task:
         _cleanup_task.cancel()
         try:

{databricks_tellr_app-0.4.3.dev3462 → databricks_tellr_app-0.4.3.dev3463}/src/api/mcp_server.py

@@ -33,7 +33,6 @@ from src.core.settings_db import (
     get_default_slide_style_id,
     get_default_template_id,
 )
-from src.domain.conversation_engine import with_legacy_marker
 from src.domain.slide_deck import SlideDeck
 from src.services.permission_service import get_permission_service
 
@@ -238,23 +237,14 @@ async def enqueue_create_job(
         #
         # MCP stays on the legacy monolith (its worker payload carries no engine
         # key, and the graph's one-shot path, spec §6.4, is not built).
-        # Since 2026-10-12 the graph is the DEFAULT engine, derived from the
-        # deck's first user message -- so a create_deck deck whose transcript
-        # did not say otherwise would resolve to the graph the first time
-        # someone chatted on it in the browser, and fail there
-        # (ConversationPinMissingError: MCP sessions are unpinned).  The
-        # persisted first message therefore carries the LEGACY opt-out; the
-        # prompt the worker runs (payload "message" below) is untouched.
-        persisted_prompt = (
-            with_legacy_marker(prompt)
-            if mode == "generate" and is_first_message
-            else prompt
-        )
+        # create_deck stores that on the session it creates (deck_mode="legacy"),
+        # so no prompt has to say it: every prompt, create or edit, is persisted
+        # verbatim.
         await asyncio.to_thread(
             session_manager.add_message,
             session_id=session_id,
             role="user",
-            content=persisted_prompt,
+            content=prompt,
             message_type="user_query",
             request_id=request_id,
         )
@@ -536,10 +526,9 @@ async def _create_deck_impl(
             session = session_manager.create_session(
                 created_by=identity.user_name,
                 agent_config=agent_config,
-                # Legacy deck: unpinned, and enqueue_create_job persists the
-                # first message with the USE LEGACY MODE opt-out so the
-                # transcript-derived engine agrees in every surface.
+                # Legacy deck: unpinned, and locked to the monolith from creation.
                 graph_capable=False,
+                deck_mode="legacy",
             )
             # create_session returns a dict (see SessionManager.create_session);
             # guard against a model-object return defensively so this stays

{databricks_tellr_app-0.4.3.dev3462 → databricks_tellr_app-0.4.3.dev3463}/src/api/routes/chat.py

@@ -37,7 +37,11 @@ from src.api.services.job_queue import (
     is_pinned_graph_configuration_error_event,
     pinned_graph_configuration_error_event_payload,
 )
-from src.api.services.session_manager import SessionNotFoundError, get_session_manager
+from src.api.services.session_manager import (
+    DeckModeLockedError,
+    SessionNotFoundError,
+    get_session_manager,
+)
 from src.core.context_utils import run_in_thread_with_context
 from src.core.database import get_db
 from src.core.permission_context import get_permission_context
@@ -48,7 +52,6 @@ from src.core.settings_db import (
 )
 from src.core.user_context import get_current_user
 from src.database.models.profile_contributor import PermissionLevel
-from src.domain.conversation_engine import selects_graph_engine
 from src.services.agent import UnsafeContentError
 from src.services.conversation_pins import ActiveGraphReleaseUnavailableError
 from src.services.permission_service import PERMISSION_PRIORITY, get_permission_service
@@ -75,6 +78,34 @@ class _EngineModeUnresolvedError(Exception):
     """The async route's engine-mode resolution (and nothing else) failed closed."""
 
 
+DECK_MODE_LOCKED_CODE = "deck_mode_locked"
+
+_DECK_MODE_LABELS = {"agent": "Agent mode", "legacy": "Legacy mode"}
+
+
+def _deck_mode_locked(exc: DeckModeLockedError) -> HTTPException:
+    """The 409 for a message asking for a Deck Mode other than the deck's locked one."""
+    label = _DECK_MODE_LABELS.get(exc.deck_mode, exc.deck_mode)
+    return HTTPException(
+        status_code=409,
+        detail={
+            "code": DECK_MODE_LOCKED_CODE,
+            "message": f"This deck's mode is already set to {label}, and it can't be changed.",
+            "deck_mode": exc.deck_mode,
+        },
+    )
+
+
+async def _mark_chat_request_error(session_manager, request_id: str, code: str) -> None:
+    """Best effort: a failed status write must never mask the 409/503 being raised."""
+    try:
+        await asyncio.to_thread(
+            session_manager.update_chat_request_status, request_id, "error", code
+        )
+    except Exception:
+        logger.warning("Failed to mark chat request %s as errored", request_id, exc_info=True)
+
+
 def _engine_mode_unavailable() -> HTTPException:
     return HTTPException(status_code=503, detail=dict(ENGINE_MODE_UNAVAILABLE_DETAIL))
 
@@ -344,7 +375,7 @@ def _maybe_create_session(request: ChatRequest, session_manager) -> bool:
                     _without_template_pin(_seeded_for_new_session(agent_config_data))
                 ),
                 created_by=current_user,
-                graph_capable=selects_graph_engine(request.message),
+                graph_capable=True,
             )
             logger.info(
                 "Created session from client-generated ID",
@@ -382,7 +413,7 @@ def _maybe_create_session(request: ChatRequest, session_manager) -> bool:
             _without_template_pin(_seeded_for_new_session(agent_config_data))
         ),
         created_by=current_user,
-        graph_capable=selects_graph_engine(request.message),
+        graph_capable=True,
     )
     request.session_id = session["session_id"]
     return True
@@ -555,6 +586,42 @@ async def send_message_streaming(
             detail="Session is currently processing another request. Please wait.",
         )
 
+    # The user message is saved BEFORE the engine is resolved: the resolver
+    # reads the deck's owner column, which this save locks atomically with the
+    # message.  Nothing has started streaming yet, so every failure here must
+    # release the lock taken above itself.
+    try:
+        session_data = await asyncio.to_thread(
+            session_manager.get_session, request.session_id
+        )
+        is_first_message = session_data.get("message_count", 0) == 0
+        await asyncio.to_thread(
+            session_manager.add_user_message,
+            request.session_id,
+            request.message,
+            message_type="user_input",
+            requested_deck_mode=request.deck_mode,
+        )
+    except SessionNotFoundError as e:
+        await asyncio.to_thread(session_manager.release_session_lock, request.session_id)
+        raise HTTPException(
+            status_code=404,
+            detail=f"Session not found: {request.session_id}",
+        ) from e
+    except DeckModeLockedError as e:
+        await asyncio.to_thread(session_manager.release_session_lock, request.session_id)
+        raise _deck_mode_locked(e) from e
+    except ActiveGraphReleaseUnavailableError as e:
+        await asyncio.to_thread(session_manager.release_session_lock, request.session_id)
+        raise HTTPException(
+            status_code=503,
+            detail="No active Graph Release available",
+        ) from e
+    except Exception as e:
+        await asyncio.to_thread(session_manager.release_session_lock, request.session_id)
+        logger.error(f"Failed to save streaming chat message: {e}")
+        raise HTTPException(status_code=500, detail="Internal server error") from e
+
     # ws4d D2 — the engine for this turn is resolved HERE, in the chat route,
     # and passed down.  Not in send_message_streaming and not in the job queue:
     # MCP's enqueue_create_job drains through the same worker as POST
@@ -606,6 +673,8 @@ async def send_message_streaming(
                     else None,
                     image_ids=request.image_ids,
                     engine_mode=engine_mode,
+                    is_first_message_override=is_first_message,
+                    user_message_persisted=True,
                 ):
                     event_queue.put(event)
             except Exception as e:
@@ -746,26 +815,26 @@ async def submit_chat_async(
         )
 
         # Capture first-message flag BEFORE persisting the user message,
-        # because add_message increments message_count.
+        # because saving the message increments message_count.
         session_data = await asyncio.to_thread(
             session_manager.get_session, request.session_id
         )
         is_first_message = session_data.get("message_count", 0) == 0
 
-        # Persist user message
+        # Persist user message (locks the deck's mode atomically with it)
         await asyncio.to_thread(
-            session_manager.add_message,
-            session_id=request.session_id,
-            role="user",
-            content=request.message,
+            session_manager.add_user_message,
+            request.session_id,
+            request.message,
             message_type="user_query",
             request_id=request_id,
+            requested_deck_mode=request.deck_mode,
         )
 
         # ws4d D2 — resolved AFTER the user message is persisted just above,
-        # because resolve_engine_mode reads the deck's EARLIEST role='user'
-        # message: on turn 1 that row has to exist already or a USE LEGACY MODE
-        # opt-out in the very first message would resolve to the default
+        # because resolve_engine_mode reads the deck owner's `deck_mode`
+        # column, which that save locks: on turn 1 the column has to be set
+        # already or a legacy first message would resolve to the NULL default
         # (graph) engine.
         #
         # FAIL CLOSED (#271 C24/C47): a failure of THIS call (and only this call)
@@ -815,6 +884,23 @@ async def submit_chat_async(
             session_manager.release_session_lock, request.session_id
         )
         raise _engine_mode_unavailable() from e.__cause__
+    except DeckModeLockedError as e:
+        await asyncio.to_thread(
+            session_manager.release_session_lock, request.session_id
+        )
+        await _mark_chat_request_error(session_manager, request_id, DECK_MODE_LOCKED_CODE)
+        raise _deck_mode_locked(e) from e
+    except ActiveGraphReleaseUnavailableError as e:
+        await asyncio.to_thread(
+            session_manager.release_session_lock, request.session_id
+        )
+        await _mark_chat_request_error(
+            session_manager, request_id, "no_active_graph_release"
+        )
+        raise HTTPException(
+            status_code=503,
+            detail="No active Graph Release available",
+        ) from e
     except Exception as e:
         # Release lock on failure
         await asyncio.to_thread(

{databricks_tellr_app-0.4.3.dev3462 → databricks_tellr_app-0.4.3.dev3463}/src/api/routes/settings/slide_styles.py

@@ -16,14 +16,9 @@ from sqlalchemy.orm import Session
 from src.api.routes._authz import require_admin
 from src.core.database import get_db, get_db_session
 from src.database.models import SlideStyleLibrary
-from src.services import slide_style_preview_fixture as preview_fixture
-from src.services import slide_style_preview_storage as preview_storage
 
 logger = logging.getLogger(__name__)
 
-# Fields whose change invalidates a generated preview (see cache-invalidation).
-_PREVIEW_AFFECTING_FIELDS = ("style_content", "image_guidelines")
-
 router = APIRouter(prefix="/slide-styles", tags=["slide-styles"])
 
 
@@ -73,26 +68,6 @@ class SlideStyleListResponse(BaseModel):
     total: int
 
 
-class SlideStylePreviewResponse(BaseModel):
-    """Read-only preview state for a slide style.
-
-    ``status`` drives the client: ``ready`` (current), ``stale`` (a usable but
-    out-of-date copy while regeneration runs), ``queued``/``generating`` (in
-    flight), ``failed`` (with optional last-known-good copy), ``missing`` (never
-    generated). HTTP is always 200; the client polls on ``status`` rather than
-    on status codes.
-    """
-    style_id: int
-    status: str
-    fingerprint: Optional[str] = None
-    slides: Optional[List[str]] = None
-    css: Optional[str] = None
-    assets: Optional[List[dict]] = None
-    generated_at: Optional[str] = None
-    error_code: Optional[str] = None
-    stale: bool = False
-
-
 # API endpoints
 
 @router.get("", response_model=SlideStyleListResponse)
@@ -263,15 +238,6 @@ def create_slide_style(
         db.refresh(style)
         
         logger.info(f"Created slide style: {style.name} (id={style.id})")
-
-        # Warm the visual preview immediately so the first viewer gets a cache
-        # hit instead of waiting on a cold generation. Deduplicated + best-effort.
-        try:
-            from src.api.services.slide_style_preview_queue import try_enqueue
-
-            try_enqueue(style.id)
-        except Exception:  # noqa: BLE001 — warming must never fail the create
-            logger.warning("Preview warm-on-create failed", exc_info=True)
         
         return SlideStyleResponse(
             id=style.id,
@@ -355,38 +321,11 @@ def update_slide_style(
             style.description = request.description
         if request.category is not None:
             style.category = request.category
-
-        # Detect preview-affecting changes BEFORE mutating, so we can invalidate
-        # the cached preview in the SAME transaction as the edit (cache-invalidation).
-        preview_affected = False
-        if request.style_content is not None and request.style_content != style.style_content:
-            preview_affected = True
-        if (
-            request.image_guidelines is not None
-            and request.image_guidelines != style.image_guidelines
-        ):
-            preview_affected = True
-
         if request.style_content is not None:
             style.style_content = request.style_content
         if request.image_guidelines is not None:
             style.image_guidelines = request.image_guidelines
 
-        if preview_affected:
-            # Bump the revision (the generation write-back guard) and reset the
-            # cached preview to 'missing' so it regenerates. The last-known-good
-            # payload row is left in storage until the next successful prune.
-            style.style_revision = (style.style_revision or 0) + 1
-            style.preview_status = "missing"
-            style.preview_fingerprint = None
-            style.preview_payload_id = None
-            style.preview_error_code = None
-            style.preview_error_message = None
-            logger.info(
-                "Invalidated slide-style preview after edit",
-                extra={"style_id": style.id, "style_revision": style.style_revision},
-            )
-
         # Update the user (skip Databricks call in test/dev to avoid network timeout)
         if os.getenv("ENVIRONMENT") in ("development", "test"):
             style.updated_by = "system"
@@ -405,16 +344,6 @@ def update_slide_style(
         db.refresh(style)
         
         logger.info(f"Updated slide style: {style.name} (id={style.id})")
-
-        # If the edit invalidated the preview, warm it right away (against the
-        # now-committed new revision) so viewers don't hit a cold regeneration.
-        if preview_affected:
-            try:
-                from src.api.services.slide_style_preview_queue import try_enqueue
-
-                try_enqueue(style.id)
-            except Exception:  # noqa: BLE001 — warming must never fail the update
-                logger.warning("Preview warm-on-update failed", exc_info=True)
         
         return SlideStyleResponse(
             id=style.id,
@@ -581,133 +510,3 @@ def set_default_slide_style(style_id: int):
             status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
             detail="Failed to set default slide style",
         )
-
-
-@router.get("/{style_id}/preview", response_model=SlideStylePreviewResponse)
-def get_slide_style_preview(
-    style_id: int,
-    db: Session = Depends(get_db),
-):
-    """Read the cached visual preview for a slide style. NEVER generates inline.
-
-    Visibility mirrors ``GET /{style_id}`` (404 parity). When the cached preview
-    is missing or stale relative to the current generation fingerprint, this
-    enqueues a deduplicated background job and returns the current state (with a
-    stale copy if one exists) so the UI stays fast and crawlers/prefetch/scroll
-    never trigger LLM cost.
-    """
-    from src.api.services.slide_style_preview_queue import try_enqueue
-
-    style = db.query(SlideStyleLibrary).filter(SlideStyleLibrary.id == style_id).first()
-    if not style:
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND,
-            detail=f"Slide style {style_id} not found",
-        )
-
-    current_fp = preview_fixture.compute_fingerprint(
-        style.style_content,
-        style.image_guidelines,
-        preview_fixture.current_builder_definition(db),
-    )
-    status_val = style.preview_status or "missing"
-
-    # Load any stored payload (ready OR last-known-good) once.
-    payload = None
-    if style.preview_payload_id:
-        payload = preview_storage.load_payload(db, style.preview_payload_id)
-
-    def _resp(status_str: str, *, include_payload: bool, stale: bool = False):
-        has = include_payload and payload
-        return SlideStylePreviewResponse(
-            style_id=style_id,
-            status=status_str,
-            fingerprint=style.preview_fingerprint if include_payload else None,
-            slides=(payload or {}).get("slides") if has else None,
-            css=(payload or {}).get("css") if has else None,
-            assets=(payload or {}).get("assets") if has else None,
-            generated_at=style.preview_generated_at.isoformat()
-            if (has and style.preview_generated_at)
-            else None,
-            error_code=style.preview_error_code,
-            stale=stale,
-        )
-
-    # Ready and current (cache hit).
-    if status_val == "ready" and style.preview_fingerprint == current_fp and payload:
-        logger.info(
-            "slide_style_preview.cache_hit",
-            extra={"style_id": style_id, "status": "ready"},
-        )
-        return _resp("ready", include_payload=True)
-
-    # Ready but stale (fingerprint moved). Serve the stale copy, kick a refresh.
-    if status_val == "ready" and payload:
-        age_s = None
-        if style.preview_generated_at:
-            from datetime import datetime as _dt
-
-            age_s = (_dt.utcnow() - style.preview_generated_at).total_seconds()
-        logger.info(
-            "slide_style_preview.cache_stale",
-            extra={"style_id": style_id, "stale_age_s": age_s},
-        )
-        try_enqueue(style_id)
-        return _resp("stale", include_payload=True, stale=True)
-
-    # In flight. Serve stale copy underneath if present. try_enqueue no-ops a
-    # live job and re-queues one whose worker died, so a viewer recovers it.
-    if status_val in ("queued", "generating"):
-        try_enqueue(style_id)
-        return _resp(status_val, include_payload=bool(payload), stale=bool(payload))
-
-    # Failed. Return last-known-good if we have one; otherwise just the error.
-    if status_val == "failed":
-        return _resp("failed", include_payload=bool(payload), stale=bool(payload))
-
-    # Missing (or unknown): enqueue and report queued.
-    try_enqueue(style_id)
-    # Re-read status: try_enqueue may have transitioned it to 'queued'.
-    return SlideStylePreviewResponse(style_id=style_id, status="queued")
-
-
-# SDR-4437 HIGH-3: workspace-global library writes are admin-only.
-@router.post(
-    "/{style_id}/preview/regenerate",
-    response_model=SlideStylePreviewResponse,
-    dependencies=[Depends(require_admin)],
-)
-def regenerate_slide_style_preview(
-    style_id: int,
-    db: Session = Depends(get_db),
-):
-    """Explicitly (re)generate a slide-style preview. Admin-only, deduplicated.
-
-    Enqueues a background job against the current style snapshot. Idempotent: if
-    a generation is already in flight this is a no-op that returns the in-flight
-    status.
-    """
-    from datetime import datetime as _dt
-
-    from src.api.services.slide_style_preview_queue import claimable_clause, try_enqueue
-
-    style = db.query(SlideStyleLibrary).filter(SlideStyleLibrary.id == style_id).first()
-    if not style:
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND,
-            detail=f"Slide style {style_id} not found",
-        )
-
-    # Force a re-attempt even from a 'failed'/'ready' terminal state by clearing
-    # to 'missing' first (in its own committed txn), then enqueue. A live job is
-    # left alone (no duplicate generation); an abandoned one is claimable.
-    db.query(SlideStyleLibrary).filter(
-        SlideStyleLibrary.id == style_id, claimable_clause(_dt.utcnow())
-    ).update({"preview_status": "missing"}, synchronize_session=False)
-    db.commit()
-
-    try_enqueue(style_id)
-    db.refresh(style)
-    return SlideStylePreviewResponse(
-        style_id=style_id, status=style.preview_status or "queued"
-    )

{databricks_tellr_app-0.4.3.dev3462 → databricks_tellr_app-0.4.3.dev3463}/src/api/routes/tour.py

@@ -65,16 +65,15 @@ def _phase1_create_session(created_by: str) -> dict:
     fixture = _load_fixture()
     sm = get_session_manager()
 
-    # Graph-capable (pinned): the fixture's chat_prompt carries no
-    # USE LEGACY MODE opt-out, so since 2026-10-12 the tour deck resolves to
-    # the graph like any other deck, and a graph turn on an unpinned session
-    # raises ConversationPinMissingError.  The fixture already ships a
-    # deck_spec for exactly this (ws4d), so a user who keeps chatting after the
-    # tour gets the default engine.
+    # Graph-capable (pinned) and locked to the agent engine from creation, so
+    # a user who keeps chatting after the tour stays on the graph.  A graph
+    # turn on an unpinned session raises ConversationPinMissingError.  The
+    # fixture already ships a deck_spec for exactly this (ws4d).
     session = sm.create_session(
         title=fixture["title"],
         created_by=created_by,
         graph_capable=True,
+        deck_mode="agent",
     )
     session_id = session["session_id"]