Sync from GitHub 49159d9b28d28aa11280480ca7ae1daa166891aa

app.py

@@ -914,7 +914,28 @@ def _run_podcast_background(
             topic_focus=topic_focus,
         )
         if "error" in result:
-            crud.update_artifact(db, artifact_id, status="failed", error_message=result["error"])
+            transcript_markdown = ""
+            transcript_path = None
+            transcript = result.get("transcript")
+            if isinstance(transcript, list) and transcript:
+                transcript_markdown = generator.format_transcript_markdown(result)
+                transcript_path = generator.save_transcript(result, str(user_id), str(notebook_id))
+            crud.update_artifact(
+                db,
+                artifact_id,
+                status="failed",
+                error_message=result["error"],
+                content=(transcript_markdown or None),
+                metadata={
+                    "audio_path": None,
+                    "transcript_path": transcript_path,
+                    **(
+                        result.get("metadata", {})
+                        if isinstance(result.get("metadata"), dict)
+                        else {}
+                    ),
+                },
+            )
         else:
             transcript_markdown = generator.format_transcript_markdown(result)
             transcript_path = generator.save_transcript(result, str(user_id), str(notebook_id))

src/artifacts/podcast_generator.py

@@ -142,10 +142,50 @@ class PodcastGenerator:
         # 3. Synthesize audio segments
         print(f"🎵 Synthesizing audio with {self.tts_provider}...")
         audio_segments = self._synthesize_segments(script, user_id, notebook_id, hosts)
+        if not audio_segments:
+            return {
+                "error": (
+                    "Transcript generated but audio synthesis failed for all segments. "
+                    "Check TTS provider credentials, quota, and configured voices."
+                ),
+                "transcript": script,
+                "audio_path": None,
+                "metadata": {
+                    "notebook_id": notebook_id,
+                    "duration_target": duration_target,
+                    "hosts": hosts,
+                    "tts_provider": self.tts_provider,
+                    "llm_provider": self.llm_provider,
+                    "llm_model": self.model,
+                    "num_segments": len(script),
+                    "topic_focus": topic_focus,
+                    "generated_at": datetime.utcnow().isoformat(),
+                },
+            }
 
         # 4. Combine audio
         print("🔗 Combining audio segments...")
         final_audio = self._combine_audio(audio_segments, user_id, notebook_id)
+        if not final_audio or not Path(final_audio).exists():
+            return {
+                "error": (
+                    "Transcript generated but final audio file was not created. "
+                    "Check ffmpeg/pydub setup and TTS output."
+                ),
+                "transcript": script,
+                "audio_path": None,
+                "metadata": {
+                    "notebook_id": notebook_id,
+                    "duration_target": duration_target,
+                    "hosts": hosts,
+                    "tts_provider": self.tts_provider,
+                    "llm_provider": self.llm_provider,
+                    "llm_model": self.model,
+                    "num_segments": len(script),
+                    "topic_focus": topic_focus,
+                    "generated_at": datetime.utcnow().isoformat(),
+                },
+            }
 
         return {
             "transcript": script,

tests/test_artifact_api.py

@@ -20,6 +20,7 @@ sys.path.insert(0, str(ROOT))
 
 from data.db import Base, get_db
 from data import crud
+import app as app_module
 from app import app
 
 
@@ -246,6 +247,45 @@ class TestPodcastEndpoint:
         data = resp.json()
         assert data["metadata"]["topic_focus"] == "neural nets"
 
+    def test_background_podcast_failure_persists_transcript(self, notebook, db_session):
+        """If audio fails but transcript exists, artifact should be failed with transcript content."""
+        artifact = crud.create_artifact(
+            db=db_session,
+            notebook_id=notebook.id,
+            artifact_type="podcast",
+            metadata={"duration": "5min"},
+        )
+
+        result_payload = {
+            "error": "Transcript generated but audio synthesis failed for all segments.",
+            "transcript": [{"speaker": "Alex", "text": "Intro text"}],
+            "audio_path": None,
+            "metadata": {"tts_provider": "elevenlabs"},
+        }
+
+        with patch("app.PodcastGenerator") as MockGen, patch("app.SessionLocal", return_value=db_session):
+            mock_gen = MagicMock()
+            mock_gen.generate_podcast.return_value = result_payload
+            mock_gen.format_transcript_markdown.return_value = "# Podcast Transcript\n\n**Alex:** Intro text"
+            mock_gen.save_transcript.return_value = "/tmp/transcript.md"
+            MockGen.return_value = mock_gen
+
+            app_module._run_podcast_background(
+                artifact_id=artifact.id,
+                user_id=1,
+                notebook_id=notebook.id,
+                duration="5min",
+                topic_focus=None,
+            )
+
+        updated = crud.get_artifact(db_session, artifact.id)
+        assert updated is not None
+        assert updated.status == "failed"
+        assert updated.content is not None
+        assert "Podcast Transcript" in updated.content
+        assert updated.error_message is not None
+        assert "audio synthesis failed" in updated.error_message.lower()
+
 
 # ── List artifacts tests ──────────────────────────────────────────────────────
 

tests/test_artifacts.py

@@ -192,6 +192,7 @@ class TestPodcastGenerator:
         env = {
             "STORAGE_BASE_DIR": str(tmp_path / "data"),
             "OPENAI_API_KEY": "test-key",
+            "TRANSCRIPT_LLM_PROVIDER": "openai",
             "TTS_PROVIDER": "edge",
             **(extra_env or {}),
         }
@@ -209,10 +210,12 @@ class TestPodcastGenerator:
         mock_llm_resp = _make_openai_chat_response(MOCK_PODCAST_LLM_RESPONSE)
 
         fake_audio = str(tmp_path / "podcast.mp3")
+        pathlib.Path(fake_audio).write_bytes(b"fake-audio")
 
         env = {
             "STORAGE_BASE_DIR": str(tmp_path / "data"),
             "OPENAI_API_KEY": "test-key",
+            "TRANSCRIPT_LLM_PROVIDER": "openai",
             "TTS_PROVIDER": "edge",
         }
         with patch.dict(os.environ, env):
@@ -245,6 +248,7 @@ class TestPodcastGenerator:
         env = {
             "STORAGE_BASE_DIR": str(tmp_path / "nonexistent"),
             "OPENAI_API_KEY": "test-key",
+            "TRANSCRIPT_LLM_PROVIDER": "openai",
             "TTS_PROVIDER": "edge",
         }
         with patch.dict(os.environ, env):
@@ -266,6 +270,7 @@ class TestPodcastGenerator:
         env = {
             "STORAGE_BASE_DIR": str(tmp_path / "data"),
             "OPENAI_API_KEY": "test-key",
+            "TRANSCRIPT_LLM_PROVIDER": "openai",
             "TTS_PROVIDER": "edge",
         }
         with patch.dict(os.environ, env):
@@ -287,7 +292,11 @@ class TestPodcastGenerator:
             "metadata": {"duration_target": "5min"},
         }
 
-        env = {"OPENAI_API_KEY": "test-key", "TTS_PROVIDER": "edge"}
+        env = {
+            "OPENAI_API_KEY": "test-key",
+            "TRANSCRIPT_LLM_PROVIDER": "openai",
+            "TTS_PROVIDER": "edge",
+        }
         with patch.dict(os.environ, env):
             with patch("src.artifacts.tts_adapter.EdgeTTS"):
                 with patch("src.artifacts.podcast_generator.OpenAI"):
@@ -314,6 +323,7 @@ class TestPodcastGenerator:
         env = {
             "STORAGE_BASE_DIR": str(tmp_path / "data"),
             "OPENAI_API_KEY": "test-key",
+            "TRANSCRIPT_LLM_PROVIDER": "openai",
             "TTS_PROVIDER": "edge",
         }
         with patch.dict(os.environ, env):
@@ -336,3 +346,36 @@ class TestPodcastGenerator:
                                 )
 
         assert result["metadata"]["topic_focus"] == "neural networks"
+
+    def test_generate_podcast_when_tts_fails_returns_error_with_transcript(self, tmp_path):
+        """If TTS produces no audio segments, generator returns an explicit error."""
+        _chroma_dir(tmp_path)
+
+        mock_store = MagicMock()
+        mock_store.query.return_value = MOCK_CHROMA_RESULTS
+        mock_llm_resp = _make_openai_chat_response(MOCK_PODCAST_LLM_RESPONSE)
+
+        env = {
+            "STORAGE_BASE_DIR": str(tmp_path / "data"),
+            "OPENAI_API_KEY": "test-key",
+            "TRANSCRIPT_LLM_PROVIDER": "openai",
+            "TTS_PROVIDER": "edge",
+        }
+        with patch.dict(os.environ, env):
+            with patch("src.artifacts.tts_adapter.EdgeTTS"):
+                with patch(
+                    "src.artifacts.podcast_generator.ChromaAdapter", return_value=mock_store
+                ):
+                    with patch("src.artifacts.podcast_generator.OpenAI") as mock_openai_cls:
+                        mock_client = MagicMock()
+                        mock_client.chat.completions.create.return_value = mock_llm_resp
+                        mock_openai_cls.return_value = mock_client
+
+                        gen = PodcastGenerator()
+                        with patch.object(gen, "_synthesize_segments", return_value=[]):
+                            result = gen.generate_podcast(user_id="1", notebook_id="1")
+
+        assert "error" in result
+        assert "audio synthesis failed" in str(result["error"]).lower()
+        assert isinstance(result.get("transcript"), list)
+        assert len(result["transcript"]) > 0

tests/test_podcast_llm_providers.py

@@ -45,8 +45,10 @@ def test_podcast_generator_ollama_provider_without_openai_key(tmp_path):
 
                     with patch("src.artifacts.podcast_generator.requests.post", return_value=mock_resp):
                         generator = PodcastGenerator(llm_provider="ollama")
-                        with patch.object(generator, "_synthesize_segments", return_value=[]):
-                            with patch.object(generator, "_combine_audio", return_value=""):
+                        fake_audio = str(tmp_path / "ollama_podcast.mp3")
+                        pathlib.Path(fake_audio).write_bytes(b"audio")
+                        with patch.object(generator, "_synthesize_segments", return_value=[fake_audio]):
+                            with patch.object(generator, "_combine_audio", return_value=fake_audio):
                                 result = generator.generate_podcast("1", "1")
 
     assert "error" not in result
@@ -84,8 +86,10 @@ def test_podcast_generator_groq_provider_without_openai_key(tmp_path):
                         mock_groq_cls.return_value = mock_groq
 
                         generator = PodcastGenerator(llm_provider="groq")
-                        with patch.object(generator, "_synthesize_segments", return_value=[]):
-                            with patch.object(generator, "_combine_audio", return_value=""):
+                        fake_audio = str(tmp_path / "groq_podcast.mp3")
+                        pathlib.Path(fake_audio).write_bytes(b"audio")
+                        with patch.object(generator, "_synthesize_segments", return_value=[fake_audio]):
+                            with patch.object(generator, "_combine_audio", return_value=fake_audio):
                                 result = generator.generate_podcast("1", "1")
 
     assert "error" not in result