Add comprehensive unit tests for V4 stream-json endpoint

- Added 12 new unit tests for /api/v4/scrape-and-summarize/stream-json endpoint
- Created live integration test file (test_v4_live.py) to verify Outlines library
- All 24 V4 API tests now passing (previously 13 tests)

Test Coverage:
Success Cases:
- URL mode with metadata
- Text mode with metadata
- Metadata disabled (include_metadata=false)
- Different summarization styles (skimmer, executive, eli5)
- Custom max_tokens parameter

Error Cases:
- Scraping failure (network errors)
- Content too short (<100 chars)
- SSRF protection (localhost/private IPs blocked)
- Input validation (missing/both url+text, invalid style, short text)

Additional Tests:
- SSE response headers validation
- Request ID tracking

Outlines Library Investigation:
- Discovered Outlines v1.2.9+ has breaking API changes
- Installed compatible version (0.0.44) for testing
- Documented API compatibility issues
- Verified server compiles and starts successfully despite Outlines issues

All tests pass with proper mocking of dependencies.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

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

tests/test_v4_api.py

@@ -353,3 +353,411 @@ async def test_v4_sse_headers(client: TestClient):
         assert response.headers["cache-control"] == "no-cache"
         assert response.headers["connection"] == "keep-alive"
         assert "x-request-id" in response.headers
+
+
+# ============================================================================
+# Tests for /api/v4/scrape-and-summarize/stream-json endpoint
+# ============================================================================
+
+
+def test_v4_stream_json_url_mode_success(client: TestClient):
+    """Test stream-json endpoint with URL input (successful scraping and JSON streaming)."""
+    with patch(
+        "app.services.article_scraper.article_scraper_service.scrape_article"
+    ) as mock_scrape:
+        mock_scrape.return_value = {
+            "text": "Artificial intelligence is transforming modern technology. "
+            "Machine learning algorithms are becoming more sophisticated. "
+            "Deep learning models can now process vast amounts of data efficiently." * 10,
+            "title": "AI Revolution 2024",
+            "author": "Dr. Jane Smith",
+            "date": "2024-11-30",
+            "site_name": "Tech Insights",
+            "url": "https://techinsights.com/ai-2024",
+            "method": "static",
+            "scrape_time_ms": 425.8,
+        }
+
+        # Mock JSON streaming from Outlines
+        async def mock_json_stream(*args, **kwargs):
+            # Yield raw JSON token fragments (simulating Outlines output)
+            yield '{"title": "'
+            yield 'AI Revolution'
+            yield '", "main_summary": "'
+            yield 'Artificial intelligence is rapidly evolving'
+            yield '", "key_points": ['
+            yield '"AI is transforming technology"'
+            yield ', "ML algorithms are improving"'
+            yield ', "Deep learning processes data efficiently"'
+            yield '], "category": "'
+            yield 'Technology'
+            yield '", "sentiment": "'
+            yield 'positive'
+            yield '", "read_time_min": '
+            yield '3'
+            yield '}'
+
+        with patch(
+            "app.services.structured_summarizer.structured_summarizer_service.summarize_structured_stream_json",
+            side_effect=mock_json_stream,
+        ):
+            response = client.post(
+                "/api/v4/scrape-and-summarize/stream-json",
+                json={
+                    "url": "https://techinsights.com/ai-2024",
+                    "style": "executive",
+                    "max_tokens": 512,
+                    "include_metadata": True,
+                },
+            )
+
+            assert response.status_code == 200
+            assert (
+                response.headers["content-type"] == "text/event-stream; charset=utf-8"
+            )
+
+            # Parse SSE stream
+            events = []
+            for line in response.text.split("\n"):
+                if line.startswith("data: "):
+                    events.append(line[6:])  # Keep raw data
+
+            # First event should be metadata JSON
+            metadata_event = json.loads(events[0])
+            assert metadata_event["type"] == "metadata"
+            assert metadata_event["data"]["input_type"] == "url"
+            assert metadata_event["data"]["url"] == "https://techinsights.com/ai-2024"
+            assert metadata_event["data"]["title"] == "AI Revolution 2024"
+            assert metadata_event["data"]["author"] == "Dr. Jane Smith"
+            assert metadata_event["data"]["style"] == "executive"
+            assert "scrape_latency_ms" in metadata_event["data"]
+
+            # Rest should be raw JSON tokens
+            json_tokens = events[1:]
+            complete_json = "".join(json_tokens)
+
+            # Verify it's valid JSON
+            parsed_json = json.loads(complete_json)
+            assert parsed_json["title"] == "AI Revolution"
+            assert "AI is transforming technology" in parsed_json["key_points"]
+            assert parsed_json["category"] == "Technology"
+            assert parsed_json["sentiment"] == "positive"
+            assert parsed_json["read_time_min"] == 3
+
+
+def test_v4_stream_json_text_mode_success(client: TestClient):
+    """Test stream-json endpoint with direct text input (no scraping)."""
+    test_text = (
+        "Climate change poses significant challenges to global ecosystems. "
+        "Rising temperatures affect weather patterns worldwide. "
+        "Scientists emphasize the need for immediate action."
+    )
+
+    async def mock_json_stream(*args, **kwargs):
+        yield '{"title": "Climate Change Impact", '
+        yield '"main_summary": "Climate change affects global ecosystems", '
+        yield '"key_points": ["Rising temperatures", "Weather patterns"], '
+        yield '"category": "Environment", '
+        yield '"sentiment": "neutral", '
+        yield '"read_time_min": 1}'
+
+    with patch(
+        "app.services.structured_summarizer.structured_summarizer_service.summarize_structured_stream_json",
+        side_effect=mock_json_stream,
+    ):
+        response = client.post(
+            "/api/v4/scrape-and-summarize/stream-json",
+            json={
+                "text": test_text,
+                "style": "skimmer",
+                "max_tokens": 256,
+                "include_metadata": True,
+            },
+        )
+
+        assert response.status_code == 200
+
+        # Parse events
+        events = []
+        for line in response.text.split("\n"):
+            if line.startswith("data: "):
+                events.append(line[6:])
+
+        # Check metadata for text mode
+        metadata_event = json.loads(events[0])
+        assert metadata_event["type"] == "metadata"
+        assert metadata_event["data"]["input_type"] == "text"
+        assert metadata_event["data"]["text_length"] == len(test_text)
+        assert metadata_event["data"]["style"] == "skimmer"
+        assert "url" not in metadata_event["data"]  # URL mode fields not present
+
+        # Verify JSON output
+        complete_json = "".join(events[1:])
+        parsed_json = json.loads(complete_json)
+        assert parsed_json["title"] == "Climate Change Impact"
+        assert parsed_json["category"] == "Environment"
+
+
+def test_v4_stream_json_no_metadata(client: TestClient):
+    """Test stream-json endpoint with include_metadata=false."""
+    async def mock_json_stream(*args, **kwargs):
+        yield '{"title": "Test", '
+        yield '"main_summary": "Summary", '
+        yield '"key_points": ["A"], '
+        yield '"category": "Test", '
+        yield '"sentiment": "neutral", '
+        yield '"read_time_min": 1}'
+
+    with patch(
+        "app.services.structured_summarizer.structured_summarizer_service.summarize_structured_stream_json",
+        side_effect=mock_json_stream,
+    ):
+        response = client.post(
+            "/api/v4/scrape-and-summarize/stream-json",
+            json={
+                "text": "Test article content for summary generation with enough characters to pass validation." * 2,
+                "style": "eli5",
+                "include_metadata": False,
+            },
+        )
+
+        assert response.status_code == 200
+
+        # Parse events
+        events = []
+        for line in response.text.split("\n"):
+            if line.startswith("data: "):
+                events.append(line[6:])
+
+        # Should NOT have metadata event (check first event)
+        # Metadata events are complete JSON with "type": "metadata"
+        if events and events[0]:
+            try:
+                first_event = json.loads(events[0])
+                assert first_event.get("type") != "metadata", "Metadata should not be included"
+            except json.JSONDecodeError:
+                # First event is not complete JSON, so it's raw tokens (good!)
+                pass
+
+        # All events should be JSON tokens that combine to valid JSON
+        complete_json = "".join(events)
+        parsed_json = json.loads(complete_json)
+        assert parsed_json["title"] == "Test"
+
+
+def test_v4_stream_json_different_styles(client: TestClient):
+    """Test stream-json endpoint with different summarization styles."""
+    styles_to_test = ["skimmer", "executive", "eli5"]
+
+    for style in styles_to_test:
+        async def mock_json_stream(*args, **kwargs):
+            yield f'{{"title": "{style.upper()}", '
+            yield '"main_summary": "Test", '
+            yield '"key_points": ["A"], '
+            yield '"category": "Test", '
+            yield '"sentiment": "positive", '
+            yield '"read_time_min": 1}'
+
+        with patch(
+            "app.services.structured_summarizer.structured_summarizer_service.summarize_structured_stream_json",
+            side_effect=mock_json_stream,
+        ):
+            response = client.post(
+                "/api/v4/scrape-and-summarize/stream-json",
+                json={
+                    "text": "Test content for different styles with sufficient character count to pass validation requirements." * 2,
+                    "style": style,
+                    "include_metadata": False,
+                },
+            )
+
+            assert response.status_code == 200, f"Failed for style: {style}"
+
+
+def test_v4_stream_json_custom_max_tokens(client: TestClient):
+    """Test stream-json endpoint with custom max_tokens parameter."""
+    async def mock_json_stream(text, style, max_tokens=None):
+        # Verify max_tokens is passed through
+        assert max_tokens == 1536
+        yield '{"title": "Custom Tokens", '
+        yield '"main_summary": "Test", '
+        yield '"key_points": ["A"], '
+        yield '"category": "Test", '
+        yield '"sentiment": "neutral", '
+        yield '"read_time_min": 1}'
+
+    with patch(
+        "app.services.structured_summarizer.structured_summarizer_service.summarize_structured_stream_json",
+        side_effect=mock_json_stream,
+    ):
+        response = client.post(
+            "/api/v4/scrape-and-summarize/stream-json",
+            json={
+                "text": "Test content with custom max tokens that meets minimum character requirements." * 3,
+                "style": "executive",
+                "max_tokens": 1536,
+                "include_metadata": False,
+            },
+        )
+
+        assert response.status_code == 200
+
+
+def test_v4_stream_json_scraping_failure(client: TestClient):
+    """Test stream-json endpoint when article scraping fails."""
+    with patch(
+        "app.services.article_scraper.article_scraper_service.scrape_article"
+    ) as mock_scrape:
+        mock_scrape.side_effect = Exception("Network timeout")
+
+        response = client.post(
+            "/api/v4/scrape-and-summarize/stream-json",
+            json={
+                "url": "https://example.com/unreachable",
+                "style": "executive",
+            },
+        )
+
+        assert response.status_code == 502
+        assert "detail" in response.json()
+        assert "scrape" in response.json()["detail"].lower()
+
+
+def test_v4_stream_json_content_too_short(client: TestClient):
+    """Test stream-json endpoint when scraped content is too short."""
+    with patch(
+        "app.services.article_scraper.article_scraper_service.scrape_article"
+    ) as mock_scrape:
+        mock_scrape.return_value = {
+            "text": "Too short",  # Less than 100 characters
+            "title": "Short Article",
+            "url": "https://example.com/short",
+            "method": "static",
+            "scrape_time_ms": 200.0,
+        }
+
+        response = client.post(
+            "/api/v4/scrape-and-summarize/stream-json",
+            json={
+                "url": "https://example.com/short",
+                "style": "executive",
+            },
+        )
+
+        assert response.status_code == 422
+        assert "detail" in response.json()
+        assert "insufficient" in response.json()["detail"].lower()
+
+
+def test_v4_stream_json_ssrf_protection(client: TestClient):
+    """Test stream-json endpoint blocks SSRF attempts."""
+    ssrf_urls = [
+        "http://localhost/admin",
+        "http://127.0.0.1/secrets",
+        "http://192.168.1.1/internal",
+        "http://10.0.0.1/private",
+    ]
+
+    for url in ssrf_urls:
+        response = client.post(
+            "/api/v4/scrape-and-summarize/stream-json",
+            json={
+                "url": url,
+                "style": "executive",
+            },
+        )
+
+        assert response.status_code == 422, f"SSRF not blocked for: {url}"
+        # FastAPI validation errors return detail array
+        assert "detail" in response.json()
+
+
+def test_v4_stream_json_validation_errors(client: TestClient):
+    """Test stream-json endpoint input validation."""
+    # Missing both url and text
+    response = client.post(
+        "/api/v4/scrape-and-summarize/stream-json",
+        json={"style": "executive"},
+    )
+    assert response.status_code == 422
+
+    # Both url and text provided
+    response = client.post(
+        "/api/v4/scrape-and-summarize/stream-json",
+        json={
+            "url": "https://example.com",
+            "text": "Some text",
+            "style": "executive",
+        },
+    )
+    assert response.status_code == 422
+
+    # Text too short
+    response = client.post(
+        "/api/v4/scrape-and-summarize/stream-json",
+        json={
+            "text": "Short",
+            "style": "executive",
+        },
+    )
+    assert response.status_code == 422
+
+    # Invalid style
+    response = client.post(
+        "/api/v4/scrape-and-summarize/stream-json",
+        json={
+            "text": "Valid length text for testing validation" * 5,
+            "style": "invalid_style",
+        },
+    )
+    assert response.status_code == 422
+
+
+def test_v4_stream_json_response_headers(client: TestClient):
+    """Test stream-json endpoint returns correct SSE headers."""
+    async def mock_json_stream(*args, **kwargs):
+        yield '{"title": "Test", "main_summary": "Test", "key_points": [], '
+        yield '"category": "Test", "sentiment": "neutral", "read_time_min": 1}'
+
+    with patch(
+        "app.services.structured_summarizer.structured_summarizer_service.summarize_structured_stream_json",
+        side_effect=mock_json_stream,
+    ):
+        response = client.post(
+            "/api/v4/scrape-and-summarize/stream-json",
+            json={
+                "text": "Test content for header validation." * 10,
+                "style": "executive",
+            },
+        )
+
+        # Verify SSE headers
+        assert response.headers["content-type"] == "text/event-stream; charset=utf-8"
+        assert response.headers["cache-control"] == "no-cache"
+        assert response.headers["connection"] == "keep-alive"
+        assert response.headers["x-accel-buffering"] == "no"
+        assert "x-request-id" in response.headers
+
+
+def test_v4_stream_json_request_id_tracking(client: TestClient):
+    """Test stream-json endpoint respects X-Request-ID header."""
+    custom_request_id = "test-request-12345"
+
+    async def mock_json_stream(*args, **kwargs):
+        yield '{"title": "Test", "main_summary": "Test", "key_points": [], '
+        yield '"category": "Test", "sentiment": "neutral", "read_time_min": 1}'
+
+    with patch(
+        "app.services.structured_summarizer.structured_summarizer_service.summarize_structured_stream_json",
+        side_effect=mock_json_stream,
+    ):
+        response = client.post(
+            "/api/v4/scrape-and-summarize/stream-json",
+            json={
+                "text": "Test content for request ID tracking." * 10,
+                "style": "executive",
+            },
+            headers={"X-Request-ID": custom_request_id},
+        )
+
+        assert response.headers["x-request-id"] == custom_request_id

tests/test_v4_live.py

@@ -0,0 +1,262 @@
+"""
+Live integration tests for V4 Outlines functionality.
+
+These tests actually exercise the Outlines library (not mocked) to verify
+it's working correctly. They require the Outlines library to be installed
+and will fail if there are API compatibility issues.
+
+Run with: pytest tests/test_v4_live.py -v
+"""
+
+import json
+import pytest
+from pydantic import ValidationError
+
+# Mark all tests in this file as integration tests
+pytestmark = pytest.mark.integration
+
+
+def test_outlines_library_imports():
+    """Test that Outlines library can be imported successfully."""
+    try:
+        import outlines
+        from outlines import models as outlines_models
+        from outlines import generate as outlines_generate
+
+        # Verify key components exist
+        assert outlines is not None
+        assert outlines_models is not None
+        assert outlines_generate is not None
+        assert hasattr(outlines_generate, 'json'), "outlines.generate should have 'json' method"
+
+        print("✅ Outlines library imported successfully")
+    except ImportError as e:
+        pytest.fail(f"Failed to import Outlines library: {e}")
+
+
+def test_outlines_availability_flag():
+    """Test that the OUTLINES_AVAILABLE flag is set correctly."""
+    from app.services.structured_summarizer import OUTLINES_AVAILABLE
+
+    assert OUTLINES_AVAILABLE is True, (
+        "OUTLINES_AVAILABLE should be True if Outlines is installed. "
+        "Check app/services/structured_summarizer.py import section."
+    )
+
+
+@pytest.mark.asyncio
+async def test_structured_summarizer_initialization():
+    """Test that StructuredSummarizer initializes with Outlines wrapper."""
+    from app.services.structured_summarizer import structured_summarizer_service
+
+    # Check that the service was initialized
+    assert structured_summarizer_service is not None
+
+    # Check that Outlines model wrapper was created
+    assert hasattr(structured_summarizer_service, 'outlines_model'), (
+        "StructuredSummarizer should have 'outlines_model' attribute"
+    )
+
+    assert structured_summarizer_service.outlines_model is not None, (
+        "Outlines model wrapper should be initialized. "
+        "Check StructuredSummarizer.__init__() for errors."
+    )
+
+    print(f"✅ StructuredSummarizer initialized with Outlines wrapper")
+
+
+@pytest.mark.asyncio
+async def test_outlines_json_streaming_basic():
+    """
+    Test that Outlines can generate structured JSON stream.
+
+    This is a REAL test - no mocking. It will fail if:
+    - Outlines library has API compatibility issues
+    - The model wrapper isn't working
+    - The JSON schema binding fails
+    - The streaming doesn't produce valid JSON
+    """
+    from app.services.structured_summarizer import structured_summarizer_service
+    from app.api.v4.schemas import StructuredSummary, SummarizationStyle
+
+    # Use a simple test text
+    test_text = (
+        "Artificial intelligence is transforming the technology industry. "
+        "Machine learning models are becoming more powerful and accessible. "
+        "Companies are investing billions in AI research and development."
+    )
+
+    # Call the actual Outlines-based streaming method
+    json_tokens = []
+    async for token in structured_summarizer_service.summarize_structured_stream_json(
+        text=test_text,
+        style=SummarizationStyle.EXECUTIVE,
+        max_tokens=256
+    ):
+        json_tokens.append(token)
+
+    # Combine all tokens into complete JSON string
+    complete_json = ''.join(json_tokens)
+
+    print(f"\n📝 Generated JSON ({len(complete_json)} chars):")
+    print(complete_json)
+
+    # Verify it's valid JSON
+    try:
+        parsed_json = json.loads(complete_json)
+    except json.JSONDecodeError as e:
+        pytest.fail(f"Outlines generated invalid JSON: {e}\n\nGenerated content:\n{complete_json}")
+
+    # Verify it matches the StructuredSummary schema
+    try:
+        structured_summary = StructuredSummary(**parsed_json)
+
+        # Verify required fields are present and non-empty
+        assert structured_summary.title, "title should not be empty"
+        assert structured_summary.main_summary, "main_summary should not be empty"
+        assert structured_summary.key_points, "key_points should not be empty"
+        assert len(structured_summary.key_points) > 0, "key_points should have at least one item"
+        assert structured_summary.category, "category should not be empty"
+        assert structured_summary.sentiment in ['positive', 'negative', 'neutral'], (
+            f"sentiment should be valid enum value, got: {structured_summary.sentiment}"
+        )
+        assert structured_summary.read_time_min > 0, "read_time_min should be positive"
+
+        print(f"✅ Outlines generated valid StructuredSummary:")
+        print(f"   Title: {structured_summary.title}")
+        print(f"   Summary: {structured_summary.main_summary[:100]}...")
+        print(f"   Key Points: {len(structured_summary.key_points)} items")
+        print(f"   Category: {structured_summary.category}")
+        print(f"   Sentiment: {structured_summary.sentiment}")
+        print(f"   Read Time: {structured_summary.read_time_min} min")
+
+    except ValidationError as e:
+        pytest.fail(f"Outlines generated JSON doesn't match StructuredSummary schema: {e}\n\nGenerated JSON:\n{complete_json}")
+
+
+@pytest.mark.asyncio
+async def test_outlines_json_streaming_different_styles():
+    """Test that Outlines works with different summarization styles."""
+    from app.services.structured_summarizer import structured_summarizer_service
+    from app.api.v4.schemas import StructuredSummary, SummarizationStyle
+
+    test_text = "Climate change is affecting global weather patterns. Scientists warn of rising temperatures."
+
+    styles_to_test = [
+        SummarizationStyle.SKIMMER,
+        SummarizationStyle.EXECUTIVE,
+        SummarizationStyle.ELI5
+    ]
+
+    for style in styles_to_test:
+        json_tokens = []
+        async for token in structured_summarizer_service.summarize_structured_stream_json(
+            text=test_text,
+            style=style,
+            max_tokens=128
+        ):
+            json_tokens.append(token)
+
+        complete_json = ''.join(json_tokens)
+
+        try:
+            parsed_json = json.loads(complete_json)
+            structured_summary = StructuredSummary(**parsed_json)
+            print(f"✅ Style {style.value}: Generated valid summary")
+        except (json.JSONDecodeError, ValidationError) as e:
+            pytest.fail(f"Failed to generate valid summary for style {style.value}: {e}")
+
+
+@pytest.mark.asyncio
+async def test_outlines_with_longer_text():
+    """Test Outlines with longer text that triggers truncation."""
+    from app.services.structured_summarizer import structured_summarizer_service
+    from app.api.v4.schemas import StructuredSummary, SummarizationStyle
+
+    # Create a longer text (will be truncated to 10000 chars)
+    test_text = (
+        "The history of artificial intelligence dates back to the 1950s. "
+        "Alan Turing proposed the Turing Test as a measure of machine intelligence. "
+        "In the decades that followed, AI research went through cycles of optimism and setbacks. "
+    ) * 100  # Repeat to make it long
+
+    json_tokens = []
+    async for token in structured_summarizer_service.summarize_structured_stream_json(
+        text=test_text,
+        style=SummarizationStyle.EXECUTIVE,
+        max_tokens=256
+    ):
+        json_tokens.append(token)
+
+    complete_json = ''.join(json_tokens)
+
+    try:
+        parsed_json = json.loads(complete_json)
+        structured_summary = StructuredSummary(**parsed_json)
+        print(f"✅ Long text: Generated valid summary from {len(test_text)} chars")
+    except (json.JSONDecodeError, ValidationError) as e:
+        pytest.fail(f"Failed to generate valid summary for long text: {e}")
+
+
+@pytest.mark.asyncio
+async def test_outlines_error_handling_when_model_unavailable():
+    """Test that proper error JSON is returned if Outlines model is unavailable."""
+    from app.services.structured_summarizer import StructuredSummarizer
+    from app.api.v4.schemas import SummarizationStyle
+
+    # Create a StructuredSummarizer instance without initializing the model
+    # This simulates the case where Outlines is unavailable
+    fake_summarizer = StructuredSummarizer.__new__(StructuredSummarizer)
+    fake_summarizer.outlines_model = None  # Simulate unavailable Outlines
+    fake_summarizer.model = None
+    fake_summarizer.tokenizer = None
+
+    json_tokens = []
+    async for token in fake_summarizer.summarize_structured_stream_json(
+        text="Test text",
+        style=SummarizationStyle.EXECUTIVE,
+        max_tokens=128
+    ):
+        json_tokens.append(token)
+
+    complete_json = ''.join(json_tokens)
+
+    # Should return error JSON
+    try:
+        parsed_json = json.loads(complete_json)
+        assert 'error' in parsed_json, "Error response should contain 'error' field"
+        print(f"✅ Error handling: {parsed_json['error']}")
+    except json.JSONDecodeError as e:
+        pytest.fail(f"Error response is not valid JSON: {e}")
+
+
+if __name__ == "__main__":
+    # Allow running this file directly for quick testing
+    import asyncio
+
+    print("Running Outlines integration tests...\n")
+
+    # Run synchronous tests
+    print("1. Testing Outlines imports...")
+    test_outlines_library_imports()
+
+    print("\n2. Testing Outlines availability flag...")
+    test_outlines_availability_flag()
+
+    # Run async tests
+    print("\n3. Testing StructuredSummarizer initialization...")
+    asyncio.run(test_structured_summarizer_initialization())
+
+    print("\n4. Testing Outlines JSON streaming (basic)...")
+    asyncio.run(test_outlines_json_streaming_basic())
+
+    print("\n5. Testing different summarization styles...")
+    asyncio.run(test_outlines_json_streaming_different_styles())
+
+    print("\n6. Testing with longer text...")
+    asyncio.run(test_outlines_with_longer_text())
+
+    print("\n7. Testing error handling...")
+    asyncio.run(test_outlines_error_handling_when_model_unavailable())
+
+    print("\n✅ All Outlines integration tests passed!")