feat: handle audio and image output models from OpenRouter

OpenRouter exposes models that return audio transcripts (message.audio)
and generated images (message.images) instead of text in message.content.
Without this fix those models return an empty response in Open WebUI.

- Add _format_image_output() to render image URLs as markdown image tags
- In _non_stream_response: fall back to audio.transcript when content is
  empty/None, and append any images as markdown after the text content
- In _stream_response: use delta.audio.transcript as the streamed text
  when delta.content is absent (audio-streaming models)
- Add 23 unit tests covering all new paths (section 34 in test_pipe.py)

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

Author: sena-labs

openrouter_pipe.py

@@ -156,6 +156,18 @@ def _format_cost_info(usage: dict, currency: str = "USD") -> str:
     return f"\n\n---\n*{' · '.join(parts)}*"
 
 
+def _format_image_output(images: list) -> str:
+    """Format OpenRouter image output objects as markdown image tags."""
+    parts = []
+    for img in (images or []):
+        if not isinstance(img, dict):
+            continue
+        url = (img.get("image_url") or {}).get("url", "")
+        if url:
+            parts.append(f"![Generated image]({url})")
+    return "\n\n".join(parts)
+
+
 class Pipe:
     class Valves(BaseModel):
         OPENROUTER_API_KEY: str = Field(
@@ -859,14 +871,25 @@ def _non_stream_response(self, headers: dict, payload: dict) -> str:
             citations = res.get("citations", [])
 
             reasoning = _insert_citations(message.get("reasoning", ""), citations)
-            content = _insert_citations(message.get("content", ""), citations)
+            content = _insert_citations(message.get("content") or "", citations)
             rendered_citations = _format_citation_list(citations)
 
+            # Audio output: show transcript when the model returns audio instead of text
+            audio_obj = message.get("audio") or {}
+            if audio_obj and not content:
+                transcript = audio_obj.get("transcript", "")
+                content = transcript or "*[Audio response — transcript not available.]*"
+
+            # Image output: render generated images as markdown
+            image_md = _format_image_output(message.get("images") or [])
+
             final_parts = []
             if reasoning:
                 final_parts.append(f"<think>\n{reasoning}\n</think>\n")
             if content:
                 final_parts.append(content)
+            if image_md:
+                final_parts.append(image_md)
 
             # Show which fallback model actually responded
             actual_model = res.get("model", "")
@@ -951,7 +974,13 @@ def _close_think_tag():
                 first_choice = choices[0] if choices and isinstance(choices[0], dict) else {}
                 delta = first_choice.get("delta", {})
                 reasoning = delta.get("reasoning", "")
-                content = delta.get("content", "")
+                content = delta.get("content") or ""
+
+                # Audio transcript fallback: stream the transcript when the model
+                # returns audio instead of text (e.g. openai/gpt-audio).
+                if not content:
+                    audio_delta = delta.get("audio") or {}
+                    content = audio_delta.get("transcript", "")
 
                 if reasoning:
                     if not in_think:

test_pipe.py

@@ -2109,6 +2109,167 @@ async def _test_pipe_no_msgs_key():
 _assert("USD" in _cc_values, "COST_CURRENCY options: USD present")
 _assert("EUR" in _cc_values, "COST_CURRENCY options: EUR present")
 
+# ══════════════════════════════════════════════════════════════════════════════
+# 34. Audio and image output model support
+# ══════════════════════════════════════════════════════════════════════════════
+
+_section("34. Audio / image output model support")
+
+# 34a. _format_image_output — empty list returns empty string
+from openrouter_pipe import _format_image_output
+_assert(_format_image_output([]) == "", "_format_image_output: empty list → empty string")
+_assert(_format_image_output(None) == "", "_format_image_output: None → empty string")
+
+# 34b. Single image with valid URL → markdown tag
+_img_single = [{"image_url": {"url": "data:image/png;base64,ABC=="}}]
+_result_img = _format_image_output(_img_single)
+_assert(_result_img == "![Generated image](data:image/png;base64,ABC==)", "_format_image_output: single image → markdown tag")
+
+# 34c. Multiple images → joined with double newline
+_img_multi = [
+    {"image_url": {"url": "data:image/png;base64,AAA=="}},
+    {"image_url": {"url": "data:image/png;base64,BBB=="}},
+]
+_result_multi = _format_image_output(_img_multi)
+_assert("![Generated image](data:image/png;base64,AAA==)" in _result_multi, "_format_image_output: multi — first image present")
+_assert("![Generated image](data:image/png;base64,BBB==)" in _result_multi, "_format_image_output: multi — second image present")
+_assert("\n\n" in _result_multi, "_format_image_output: multi — separated by double newline")
+
+# 34d. Non-dict items in list are skipped gracefully
+_img_mixed = ["not_a_dict", {"image_url": {"url": "https://example.com/img.png"}}, 42]
+_result_mixed = _format_image_output(_img_mixed)
+_assert("https://example.com/img.png" in _result_mixed, "_format_image_output: non-dict items skipped, valid item rendered")
+_assert("not_a_dict" not in _result_mixed, "_format_image_output: string item not in output")
+
+# 34e. Image dict missing 'url' key → skipped
+_img_no_url = [{"image_url": {}}, {"image_url": {"url": ""}}]
+_assert(_format_image_output(_img_no_url) == "", "_format_image_output: missing/empty url → empty string")
+
+# ── Non-streaming audio response ───────────────────────────────────────────
+
+_pipe34 = Pipe()
+_pipe34.valves = Pipe.Valves(OPENROUTER_API_KEY="k")
+
+# 34f. Audio model with transcript → transcript used as content
+_mock_audio = MagicMock()
+_mock_audio.json.return_value = {
+    "choices": [{
+        "message": {
+            "content": None,
+            "audio": {"transcript": "Hello from audio", "data": "base64data...", "id": "audio_123"},
+        }
+    }]
+}
+with patch.object(_pipe34, "_retryable_request", return_value=_mock_audio):
+    _audio_result = _pipe34._non_stream_response({}, {})
+_assert("Hello from audio" in _audio_result, "non-stream audio: transcript used as content")
+
+# 34g. Audio model without transcript → placeholder message returned
+_mock_audio_no_transcript = MagicMock()
+_mock_audio_no_transcript.json.return_value = {
+    "choices": [{
+        "message": {
+            "content": None,
+            "audio": {"data": "base64audiodata...", "id": "audio_456"},
+        }
+    }]
+}
+with patch.object(_pipe34, "_retryable_request", return_value=_mock_audio_no_transcript):
+    _audio_no_tx_result = _pipe34._non_stream_response({}, {})
+_assert("transcript not available" in _audio_no_tx_result, "non-stream audio no transcript: placeholder shown")
+
+# 34h. Audio model with both content and audio → text content takes priority
+_mock_audio_with_content = MagicMock()
+_mock_audio_with_content.json.return_value = {
+    "choices": [{
+        "message": {
+            "content": "Text response",
+            "audio": {"transcript": "Audio transcript", "data": "base64..."},
+        }
+    }]
+}
+with patch.object(_pipe34, "_retryable_request", return_value=_mock_audio_with_content):
+    _audio_content_result = _pipe34._non_stream_response({}, {})
+_assert("Text response" in _audio_content_result, "non-stream audio+content: text content preserved")
+_assert("Audio transcript" not in _audio_content_result, "non-stream audio+content: transcript not used when content present")
+
+# 34i. Image output model → markdown image tag in response
+_mock_image = MagicMock()
+_mock_image.json.return_value = {
+    "choices": [{
+        "message": {
+            "content": None,
+            "images": [{"image_url": {"url": "data:image/png;base64,IMGDATA=="}}],
+        }
+    }]
+}
+with patch.object(_pipe34, "_retryable_request", return_value=_mock_image):
+    _image_result = _pipe34._non_stream_response({}, {})
+_assert("![Generated image]" in _image_result, "non-stream image: markdown image tag present")
+_assert("IMGDATA==" in _image_result, "non-stream image: URL data in output")
+
+# 34j. Image output with text content → both text and image in response
+_mock_image_with_text = MagicMock()
+_mock_image_with_text.json.return_value = {
+    "choices": [{
+        "message": {
+            "content": "Here is the image:",
+            "images": [{"image_url": {"url": "data:image/png;base64,IMGDATA2=="}}],
+        }
+    }]
+}
+with patch.object(_pipe34, "_retryable_request", return_value=_mock_image_with_text):
+    _image_text_result = _pipe34._non_stream_response({}, {})
+_assert("Here is the image:" in _image_text_result, "non-stream image+text: text preserved")
+_assert("![Generated image]" in _image_text_result, "non-stream image+text: image markdown present")
+
+# 34k. message.content = None handled without crash (or "")
+_mock_content_null = MagicMock()
+_mock_content_null.json.return_value = {
+    "choices": [{"message": {"content": None}}]
+}
+with patch.object(_pipe34, "_retryable_request", return_value=_mock_content_null):
+    _null_result = _pipe34._non_stream_response({}, {})
+_assert(isinstance(_null_result, str), "non-stream content=None: returns string (no crash)")
+
+# ── Streaming audio response ────────────────────────────────────────────────
+
+_pipe34s = Pipe()
+_pipe34s.valves = Pipe.Valves(OPENROUTER_API_KEY="k")
+
+# 34l. Audio transcript in streaming delta → yielded as content
+_sse_audio_chunks = [
+    b"data: " + json.dumps({"choices": [{"delta": {"content": "", "audio": {"transcript": "Hello "}}}]}).encode(),
+    b"data: " + json.dumps({"choices": [{"delta": {"content": "", "audio": {"transcript": "world"}}}]}).encode(),
+    b"data: [DONE]",
+]
+with patch.object(_pipe34s, "_retryable_request", return_value=_make_sse_response(_sse_audio_chunks)):
+    _stream_audio_chunks = list(_pipe34s._stream_response({}, {}))
+_stream_audio_full = "".join(_stream_audio_chunks)
+_assert("Hello " in _stream_audio_full, "stream audio: first transcript chunk yielded")
+_assert("world" in _stream_audio_full, "stream audio: second transcript chunk yielded")
+
+# 34m. Mixed stream: normal content chunks + audio transcript fallback
+_sse_mixed_chunks = [
+    b"data: " + json.dumps({"choices": [{"delta": {"content": "Text first"}}]}).encode(),
+    b"data: " + json.dumps({"choices": [{"delta": {"content": "", "audio": {"transcript": " then audio"}}}]}).encode(),
+    b"data: [DONE]",
+]
+with patch.object(_pipe34s, "_retryable_request", return_value=_make_sse_response(_sse_mixed_chunks)):
+    _mixed_chunks = list(_pipe34s._stream_response({}, {}))
+_mixed_full = "".join(_mixed_chunks)
+_assert("Text first" in _mixed_full, "stream mixed: text content chunk present")
+_assert("then audio" in _mixed_full, "stream mixed: audio transcript chunk present")
+
+# 34n. Stream delta with content=None → handled as empty (no crash)
+_sse_null_content = [
+    b"data: " + json.dumps({"choices": [{"delta": {"content": None}}]}).encode(),
+    b"data: [DONE]",
+]
+with patch.object(_pipe34s, "_retryable_request", return_value=_make_sse_response(_sse_null_content)):
+    _null_chunks = list(_pipe34s._stream_response({}, {}))
+_assert(isinstance("".join(_null_chunks), str), "stream content=None delta: no crash")
+
 # ══════════════════════════════════════════════════════════════════════════════
 # Summary
 # ══════════════════════════════════════════════════════════════════════════════