feat(adapters/vlm): Sprint A14-S45 — 4 VLM adapters natifs (Phase 6 done)

4 VLM adapters (Vision-Language Models) livrés natifs au contrat
StepExecutor : ils consomment IMAGE et produisent RAW_TEXT via prompt
multimodal, complémentaires aux 5 OCR dédiés (Phase 2).

picarones/adapters/vlm/base.py
------------------------------
BaseVLMAdapter hérite de BaseLLMAdapter et surcharge :
- input_types = {IMAGE} (override de BaseLLMAdapter qui demandait
RAW_TEXT) ;
- output_types = {RAW_TEXT} (override de CORRECTED_TEXT) ;
- DEFAULT_TRANSCRIPTION_PROMPT (configurable via
config["transcription_prompt"]) ;
- execute(inputs, params, context) :
· valide IMAGE input + URI + fichier existe → OCRAdapterError ;
· encode l'image en base64 ;
· appelle self.complete(prompt, image_b64) avec retry hérité ;
· si LLMResult.error → OCRAdapterError ;
· écrit dans <stem>.<name>.txt à côté de l'image ;
· retourne Artifact RAW_TEXT avec id "<doc>:<name>:raw_text",
produced_by_step="vlm_transcription".

4 adapters concrets via MRO multiple
------------------------------------
Chaque adapter VLM hérite à la fois de BaseVLMAdapter (contrat S45)
et de son LLM sibling (api_call, retry, validation API key) :

- AnthropicVLMAdapter(BaseVLMAdapter, AnthropicAdapter) : Claude
Sonnet/Opus avec vision.
- OpenAIVLMAdapter(BaseVLMAdapter, OpenAIAdapter) : gpt-4o,
gpt-4-turbo, gpt-4-vision-preview.
- MistralVLMAdapter(BaseVLMAdapter, MistralAdapter) : pixtral-12b-2409
(default override), pixtral-large-latest.
- OllamaVLMAdapter(BaseVLMAdapter, OllamaAdapter) : llava (default),
bakllava, llama3.2-vision (local).

L'ordre du MRO (BaseVLMAdapter d'abord) garantit que input_types,
output_types, execute() viennent de BaseVLMAdapter ; _call,
default_model (sauf override), retry, etc. viennent du sibling LLM.

Pas un shim
-----------
Les VLM adapters ne wrappent pas les LLM adapters ; ils étendent
le même provider avec un mode d'usage différent (vision vs texte)
via héritage multiple — chaque concret est first-class avec son
propre execute() et name.

Tests S45 dédiés (30 nouveaux)
------------------------------
- BaseVLMAdapterContract : input_types={IMAGE}, output_types=
{RAW_TEXT}, execution_mode="io".
- VLMExecuteNominal : transcription basique → fichier
<stem>.<name>.txt, image base64 passée au LLM, artifact id correct
avec produced_by_step="vlm_transcription", custom prompt via
config.
- VLMExecuteErrors : IMAGE manquant, sans URI, fichier inexistant,
VLM call failing → tous OCRAdapterError.
- ConcreteVLMAdapters (4 × 4 paramétrés) : chaque adapter
(Anthropic/OpenAI/Mistral/Ollama) a le bon name, input_types,
output_types, execute. Mistral default model contient "pixtral",
Ollama contient "llava".
- VLMPipelineIntegration : un VLM adapter se branche directement
comme step de pipeline (test bout-en-bout).

Tests : 4911 passed, 11 skipped (vs 4881 avant : +30 S45).
Lint : ruff check picarones/ tests/ → All checks passed.

Phase 6 récapitulatif
---------------------
| Sprint | Composant | Tests | Total |
|--------|--------------------------|-------|-------|
| S44 | BaseLLMAdapter execute() | 18 | +18 |
| S45 | 4 VLM adapters natifs | 30 | +30 |

Total Phase 6 : 48 nouveaux tests, 8 adapters LLM/VLM nativement
intégrés au pipeline.

https://claude.ai/code/session_011XQZNitg1rCgia8ZD1a2hP

picarones/adapters/vlm/__init__.py

@@ -1,20 +1,42 @@
-"""Adaptateurs VLM (Vision-Language Models).
+"""Adapters VLM (Vision-Language Models) — Sprint A14-S45.
 
-Volontairement vide à la livraison du rewrite ciblé.  Les VLM
-arrivent post-livraison une fois que le pattern d'adapter LLM est
-stabilisé et que les vues d'évaluation
-(``HallucinationView``, ``ReconstructionView``) sont en place pour
-les comparer honnêtement avec les pipelines OCR+LLM (cf.
-``BACKLOG_POST_LIVRAISON.md`` §2.2).
+VLM = transcription directe par un modèle généraliste avec vision.
+Distinct des OCR dédiés (Tesseract, Pero, Mistral OCR, Google Vision,
+Azure DI) — un VLM consomme IMAGE et produit RAW_TEXT via prompt
+multimodal, sans layout structuré natif.
 
-Cibles à terme : Qwen-VL, Gemini Vision, GPT-4o Vision, Claude
-Sonnet/Opus Vision, Pixtral.
+Adapters livrés
+---------------
+- ``AnthropicVLMAdapter`` : Claude Sonnet/Opus avec vision.
+- ``OpenAIVLMAdapter`` : GPT-4o, GPT-4-turbo, GPT-4-vision-preview.
+- ``MistralVLMAdapter`` : Pixtral 12b/Large.
+- ``OllamaVLMAdapter`` : LLaVA, BakLLaVA, llama3.2-vision (local).
 
-Note : un VLM peut produire ``RAW_TEXT`` ou ``CANONICAL_DOCUMENT``
-selon le mode (zero-shot transcription vs. document understanding).
-Le pipeline le branche selon le besoin de l'expérience.
+Convention StepExecutor :
+
+- ``input_types = {IMAGE}``
+- ``output_types = {RAW_TEXT}``
+- ``execute(inputs, params, context)`` encode l'image en base64,
+  appelle le LLM avec un prompt de transcription, écrit le texte
+  produit dans ``<stem>.<adapter_name>.txt`` à côté de l'image,
+  retourne un Artifact RAW_TEXT.
+
+Pas un shim sur les LLM adapters : c'est un mode d'usage
+distinct (vision vs texte) avec un contrat StepExecutor différent.
 """
 
 from __future__ import annotations
 
-__all__: list[str] = []
+from picarones.adapters.vlm.anthropic_vlm import AnthropicVLMAdapter
+from picarones.adapters.vlm.base import BaseVLMAdapter
+from picarones.adapters.vlm.mistral_vlm import MistralVLMAdapter
+from picarones.adapters.vlm.ollama_vlm import OllamaVLMAdapter
+from picarones.adapters.vlm.openai_vlm import OpenAIVLMAdapter
+
+__all__ = [
+    "BaseVLMAdapter",
+    "AnthropicVLMAdapter",
+    "MistralVLMAdapter",
+    "OllamaVLMAdapter",
+    "OpenAIVLMAdapter",
+]

picarones/adapters/vlm/anthropic_vlm.py

@@ -0,0 +1,32 @@
+"""``AnthropicVLMAdapter`` — Claude Sonnet/Opus en mode vision.
+
+Sprint A14-S45.  Délègue l'appel API au mécanisme de
+``AnthropicAdapter`` (qui supporte déjà la vision via le SDK
+anthropic) en surchargeant le contrat StepExecutor pour consommer
+IMAGE au lieu de RAW_TEXT.
+"""
+
+from __future__ import annotations
+
+from picarones.adapters.llm.anthropic_adapter import AnthropicAdapter
+from picarones.adapters.vlm.base import BaseVLMAdapter
+
+
+class AnthropicVLMAdapter(BaseVLMAdapter, AnthropicAdapter):
+    """VLM Claude (Sonnet/Opus avec vision).
+
+    L'ordre du MRO est important : ``BaseVLMAdapter`` d'abord pour
+    surcharger ``input_types``/``output_types``/``execute``, puis
+    ``AnthropicAdapter`` pour ``_call``/``default_model``/``name``/
+    retry/validation API key.
+
+    Modèles vision recommandés : ``claude-3-5-sonnet-latest``,
+    ``claude-3-opus-latest``.
+    """
+
+    @property
+    def name(self) -> str:
+        return "anthropic_vlm"
+
+
+__all__ = ["AnthropicVLMAdapter"]

picarones/adapters/vlm/base.py

@@ -0,0 +1,132 @@
+"""``BaseVLMAdapter`` — Sprint A14-S45.
+
+Adapter VLM (Vision-Language Model) qui hérite de ``BaseLLMAdapter``
+et surcharge le contrat StepExecutor pour consommer ``IMAGE`` au
+lieu de ``RAW_TEXT`` et produire ``RAW_TEXT`` (transcription
+directe par un VLM).
+
+Pas un shim sur les LLM adapters : c'est un mode d'usage différent
+de la même API LLM (texte vs image) — le contrat StepExecutor diffère.
+
+Différences avec ``BaseOCRAdapter`` (S26)
+-----------------------------------------
+- Un OCR (Tesseract, Pero, Mistral OCR, Google Vision, Azure DI)
+  utilise des modèles dédiés OCR avec layout structuré, confidences
+  natives, etc.
+- Un VLM (Anthropic Claude, GPT-4-Vision, Pixtral, LLaVA) fait de la
+  transcription via un modèle généraliste prompt+image.
+
+Les deux peuvent produire RAW_TEXT et être comparés en TextView ;
+la projection report explicitera ce qu'on perd côté VLM (pas de
+coordonnées spatiales nativement).
+
+Convention output : RAW_TEXT (transcription plate).  Une sous-classe
+qui produit du markdown structuré (ex. ``CANONICAL_DOCUMENT``) peut
+surcharger ``output_types``.
+"""
+
+from __future__ import annotations
+
+import base64
+import logging
+from pathlib import Path
+from typing import Any
+
+from picarones.adapters.llm.base import BaseLLMAdapter
+from picarones.adapters.ocr.base import OCRAdapterError
+from picarones.domain.artifacts import Artifact, ArtifactType
+
+logger = logging.getLogger(__name__)
+
+
+class BaseVLMAdapter(BaseLLMAdapter):
+    """Adapter VLM qui transcrit une IMAGE en RAW_TEXT.
+
+    Hérite de ``BaseLLMAdapter`` et surcharge le contrat
+    ``StepExecutor`` pour consommer ``IMAGE`` au lieu de ``RAW_TEXT``.
+
+    Parameters
+    ----------
+    model:
+        Modèle VLM (cf. sous-classes pour les défauts).
+    config:
+        Config dict ; supporte
+        ``config["transcription_prompt"]`` pour personnaliser le
+        prompt de transcription.
+    """
+
+    @property
+    def input_types(self) -> "frozenset":
+        return frozenset({ArtifactType.IMAGE})
+
+    @property
+    def output_types(self) -> "frozenset":
+        return frozenset({ArtifactType.RAW_TEXT})
+
+    DEFAULT_TRANSCRIPTION_PROMPT: str = (
+        "Transcris fidèlement le texte visible sur cette image de "
+        "document historique. Conserve l'orthographe historique, les "
+        "abréviations, et la ponctuation. Retourne uniquement le "
+        "texte transcrit, sans commentaire."
+    )
+
+    def execute(
+        self,
+        inputs: dict,
+        params: dict,
+        context: Any,
+    ) -> dict:
+        """Exécute la transcription VLM.
+
+        Lit ``inputs[IMAGE]`` (URI), encode en base64, appelle
+        ``self.complete(prompt, image_b64)``, écrit le résultat
+        dans ``<stem>.<name>.txt`` à côté de l'image, et retourne
+        ``{RAW_TEXT: Artifact}``.
+        """
+        if ArtifactType.IMAGE not in inputs:
+            raise OCRAdapterError(
+                f"{self.name} : input IMAGE manquant.",
+            )
+        image_artifact = inputs[ArtifactType.IMAGE]
+        if image_artifact.uri is None:
+            raise OCRAdapterError(
+                f"{self.name} : artefact image "
+                f"{image_artifact.id!r} sans URI.",
+            )
+        image_path = Path(image_artifact.uri)
+        if not image_path.exists():
+            raise OCRAdapterError(
+                f"{self.name} : image introuvable {image_path!r}.",
+            )
+
+        image_b64 = base64.b64encode(
+            image_path.read_bytes(),
+        ).decode("ascii")
+
+        prompt = self.config.get(
+            "transcription_prompt", self.DEFAULT_TRANSCRIPTION_PROMPT,
+        )
+
+        result = self.complete(prompt, image_b64=image_b64)
+        if not result.success:
+            raise OCRAdapterError(
+                f"{self.name} : VLM a échoué ({result.error}).",
+            )
+
+        out_path = (
+            image_path.parent / f"{image_path.stem}.{self.name}.txt"
+        )
+        out_path.write_text(result.text, encoding="utf-8")
+
+        return {
+            ArtifactType.RAW_TEXT: Artifact(
+                id=f"{context.document_id}:{self.name}:raw_text",
+                document_id=context.document_id,
+                type=ArtifactType.RAW_TEXT,
+                produced_by_step="vlm_transcription",
+                uri=str(out_path),
+            ),
+        }
+
+
+__all__ = ["BaseVLMAdapter"]

picarones/adapters/vlm/mistral_vlm.py

@@ -0,0 +1,26 @@
+"""``MistralVLMAdapter`` — Pixtral 12b/Large (vision Mistral).
+
+Sprint A14-S45.  Délègue à ``MistralAdapter`` qui supporte la
+vision via les modèles ``pixtral-12b-2409``, ``pixtral-large-latest``.
+"""
+
+from __future__ import annotations
+
+from picarones.adapters.llm.mistral_adapter import MistralAdapter
+from picarones.adapters.vlm.base import BaseVLMAdapter
+
+
+class MistralVLMAdapter(BaseVLMAdapter, MistralAdapter):
+    """VLM Mistral (pixtral-12b-2409, pixtral-large-latest)."""
+
+    @property
+    def name(self) -> str:
+        return "mistral_vlm"
+
+    @property
+    def default_model(self) -> str:
+        # Ré-définit le défaut pour pointer vers un modèle vision.
+        return "pixtral-12b-2409"
+
+
+__all__ = ["MistralVLMAdapter"]

picarones/adapters/vlm/ollama_vlm.py

@@ -0,0 +1,26 @@
+"""``OllamaVLMAdapter`` — Modèles vision locaux via Ollama.
+
+Sprint A14-S45.  Délègue à ``OllamaAdapter`` (local, sans clé API).
+Modèles vision recommandés : ``llava``, ``llava:13b``, ``bakllava``,
+``llama3.2-vision``.
+"""
+
+from __future__ import annotations
+
+from picarones.adapters.llm.ollama_adapter import OllamaAdapter
+from picarones.adapters.vlm.base import BaseVLMAdapter
+
+
+class OllamaVLMAdapter(BaseVLMAdapter, OllamaAdapter):
+    """VLM local via Ollama (llava, bakllava, llama3.2-vision)."""
+
+    @property
+    def name(self) -> str:
+        return "ollama_vlm"
+
+    @property
+    def default_model(self) -> str:
+        return "llava"
+
+
+__all__ = ["OllamaVLMAdapter"]

picarones/adapters/vlm/openai_vlm.py

@@ -0,0 +1,22 @@
+"""``OpenAIVLMAdapter`` — GPT-4-Vision / GPT-4o (vision).
+
+Sprint A14-S45.  Délègue à ``OpenAIAdapter`` qui supporte déjà la
+vision via les modèles ``gpt-4o``, ``gpt-4-turbo``,
+``gpt-4-vision-preview``.
+"""
+
+from __future__ import annotations
+
+from picarones.adapters.llm.openai_adapter import OpenAIAdapter
+from picarones.adapters.vlm.base import BaseVLMAdapter
+
+
+class OpenAIVLMAdapter(BaseVLMAdapter, OpenAIAdapter):
+    """VLM OpenAI (gpt-4o, gpt-4-turbo, gpt-4-vision-preview)."""
+
+    @property
+    def name(self) -> str:
+        return "openai_vlm"
+
+
+__all__ = ["OpenAIVLMAdapter"]

tests/adapters/vlm/test_sprint_a14_s45_vlm_adapters.py

@@ -0,0 +1,314 @@
+"""Sprint A14-S45 — VLM adapters (4 fournisseurs).
+
+Tests des 4 adapters VLM qui héritent de ``BaseVLMAdapter`` +
+leur LLM sibling (composition par MRO multiple).
+"""
+
+from __future__ import annotations
+
+import base64
+from pathlib import Path
+
+import pytest
+
+from picarones.adapters.ocr.base import OCRAdapterError
+from picarones.adapters.vlm import (
+    AnthropicVLMAdapter,
+    BaseVLMAdapter,
+    MistralVLMAdapter,
+    OllamaVLMAdapter,
+    OpenAIVLMAdapter,
+)
+from picarones.domain.artifacts import Artifact, ArtifactType
+from picarones.pipeline.types import RunContext
+
+
+# ──────────────────────────────────────────────────────────────────────
+# Helpers
+# ──────────────────────────────────────────────────────────────────────
+
+
+class _StubVLMAdapter(BaseVLMAdapter):
+    """VLM stub pour tests : retourne un texte fixe."""
+
+    def __init__(
+        self,
+        response_text="texte transcrit",
+        raise_on_call=False,
+        config=None,
+    ):
+        super().__init__(config=config or {"max_retries": 0})
+        self._response = response_text
+        self._raise = raise_on_call
+        self.last_image_b64 = None
+
+    @property
+    def name(self) -> str:
+        return "stub_vlm"
+
+    @property
+    def default_model(self) -> str:
+        return "stub-vlm-1.0"
+
+    def _call(self, prompt, image_b64=None):
+        self.last_image_b64 = image_b64
+        if self._raise:
+            raise RuntimeError("VLM crashed")
+        return self._response
+
+
+def _make_image_artifact(uri: str) -> Artifact:
+    return Artifact(
+        id="doc01:image",
+        document_id="doc01",
+        type=ArtifactType.IMAGE,
+        uri=uri,
+    )
+
+
+def _make_context() -> RunContext:
+    return RunContext(
+        document_id="doc01",
+        code_version="1.0.0",
+        pipeline_name="test",
+    )
+
+
+# ──────────────────────────────────────────────────────────────────────
+# Contrat StepExecutor (BaseVLMAdapter)
+# ──────────────────────────────────────────────────────────────────────
+
+
+class TestBaseVLMAdapterContract:
+    def test_input_types_is_image(self) -> None:
+        adapter = _StubVLMAdapter()
+        assert adapter.input_types == frozenset({ArtifactType.IMAGE})
+
+    def test_output_types_is_raw_text(self) -> None:
+        adapter = _StubVLMAdapter()
+        assert adapter.output_types == frozenset({ArtifactType.RAW_TEXT})
+
+    def test_execution_mode_is_io(self) -> None:
+        # Hérité de BaseLLMAdapter.
+        assert _StubVLMAdapter.execution_mode == "io"
+
+
+class TestVLMExecuteNominal:
+    def test_basic_transcription(self, tmp_path: Path) -> None:
+        image_path = tmp_path / "doc01.png"
+        image_path.write_bytes(b"PNGBYTES")
+        adapter = _StubVLMAdapter(response_text="ceci est le texte")
+
+        result = adapter.execute(
+            inputs={ArtifactType.IMAGE: _make_image_artifact(str(image_path))},
+            params={},
+            context=_make_context(),
+        )
+        assert ArtifactType.RAW_TEXT in result
+        produced = result[ArtifactType.RAW_TEXT]
+        assert produced.type == ArtifactType.RAW_TEXT
+        assert produced.document_id == "doc01"
+        out_path = Path(produced.uri)
+        assert out_path.exists()
+        assert out_path.read_text(encoding="utf-8") == "ceci est le texte"
+        assert out_path.name == "doc01.stub_vlm.txt"
+
+    def test_image_passed_to_llm_as_base64(self, tmp_path: Path) -> None:
+        image_path = tmp_path / "doc01.png"
+        image_path.write_bytes(b"VLM_TEST_BYTES")
+        adapter = _StubVLMAdapter()
+        adapter.execute(
+            inputs={ArtifactType.IMAGE: _make_image_artifact(str(image_path))},
+            params={},
+            context=_make_context(),
+        )
+        decoded = base64.b64decode(adapter.last_image_b64)
+        assert decoded == b"VLM_TEST_BYTES"
+
+    def test_artifact_id_uses_adapter_name(self, tmp_path: Path) -> None:
+        image_path = tmp_path / "doc01.png"
+        image_path.write_bytes(b"x")
+        adapter = _StubVLMAdapter()
+        result = adapter.execute(
+            inputs={ArtifactType.IMAGE: _make_image_artifact(str(image_path))},
+            params={},
+            context=_make_context(),
+        )
+        produced = result[ArtifactType.RAW_TEXT]
+        assert produced.id == "doc01:stub_vlm:raw_text"
+        assert produced.produced_by_step == "vlm_transcription"
+
+    def test_custom_transcription_prompt(self, tmp_path: Path) -> None:
+        image_path = tmp_path / "doc01.png"
+        image_path.write_bytes(b"x")
+        adapter = _StubVLMAdapter(config={
+            "max_retries": 0,
+            "transcription_prompt": "Custom VLM prompt",
+        })
+        # On capture le prompt en surchargeant _call.
+        captured = {}
+
+        def _capture_call(prompt, image_b64=None):
+            captured["prompt"] = prompt
+            return "x"
+
+        adapter._call = _capture_call  # type: ignore[method-assign]
+        adapter.execute(
+            inputs={ArtifactType.IMAGE: _make_image_artifact(str(image_path))},
+            params={},
+            context=_make_context(),
+        )
+        assert captured["prompt"] == "Custom VLM prompt"
+
+
+# ──────────────────────────────────────────────────────────────────────
+# Erreurs
+# ──────────────────────────────────────────────────────────────────────
+
+
+class TestVLMExecuteErrors:
+    def test_missing_image_raises(self) -> None:
+        adapter = _StubVLMAdapter()
+        with pytest.raises(OCRAdapterError, match="IMAGE manquant"):
+            adapter.execute(inputs={}, params={}, context=_make_context())
+
+    def test_image_without_uri_raises(self) -> None:
+        adapter = _StubVLMAdapter()
+        artifact = Artifact(
+            id="x",
+            document_id="doc01",
+            type=ArtifactType.IMAGE,
+            uri=None,
+        )
+        with pytest.raises(OCRAdapterError, match="sans URI"):
+            adapter.execute(
+                inputs={ArtifactType.IMAGE: artifact},
+                params={},
+                context=_make_context(),
+            )
+
+    def test_image_path_not_existing_raises(self) -> None:
+        adapter = _StubVLMAdapter()
+        with pytest.raises(OCRAdapterError, match="introuvable"):
+            adapter.execute(
+                inputs={ArtifactType.IMAGE: _make_image_artifact(
+                    "/nonexistent/img.png",
+                )},
+                params={},
+                context=_make_context(),
+            )
+
+    def test_vlm_call_failing_raises(self, tmp_path: Path) -> None:
+        image_path = tmp_path / "doc.png"
+        image_path.write_bytes(b"x")
+        adapter = _StubVLMAdapter(raise_on_call=True)
+        with pytest.raises(OCRAdapterError, match="VLM a échoué"):
+            adapter.execute(
+                inputs={ArtifactType.IMAGE: _make_image_artifact(str(image_path))},
+                params={},
+                context=_make_context(),
+            )
+
+
+# ──────────────────────────────────────────────────────────────────────
+# Adapters concrets — héritage MRO
+# ──────────────────────────────────────────────────────────────────────
+
+
+class TestConcreteVLMAdapters:
+    @pytest.mark.parametrize("adapter_cls,expected_name", [
+        (AnthropicVLMAdapter, "anthropic_vlm"),
+        (OpenAIVLMAdapter, "openai_vlm"),
+        (MistralVLMAdapter, "mistral_vlm"),
+        (OllamaVLMAdapter, "ollama_vlm"),
+    ])
+    def test_adapter_name(self, adapter_cls, expected_name) -> None:
+        adapter = adapter_cls()
+        assert adapter.name == expected_name
+
+    @pytest.mark.parametrize("adapter_cls", [
+        AnthropicVLMAdapter,
+        OpenAIVLMAdapter,
+        MistralVLMAdapter,
+        OllamaVLMAdapter,
+    ])
+    def test_adapter_input_types(self, adapter_cls) -> None:
+        # input_types vient de BaseVLMAdapter par MRO.
+        adapter = adapter_cls()
+        assert adapter.input_types == frozenset({ArtifactType.IMAGE})
+
+    @pytest.mark.parametrize("adapter_cls", [
+        AnthropicVLMAdapter,
+        OpenAIVLMAdapter,
+        MistralVLMAdapter,
+        OllamaVLMAdapter,
+    ])
+    def test_adapter_output_types(self, adapter_cls) -> None:
+        adapter = adapter_cls()
+        assert adapter.output_types == frozenset({ArtifactType.RAW_TEXT})
+
+    @pytest.mark.parametrize("adapter_cls", [
+        AnthropicVLMAdapter,
+        OpenAIVLMAdapter,
+        MistralVLMAdapter,
+        OllamaVLMAdapter,
+    ])
+    def test_adapter_has_execute(self, adapter_cls) -> None:
+        # execute() vient de BaseVLMAdapter par MRO.
+        assert hasattr(adapter_cls, "execute")
+
+    def test_mistral_default_model_is_pixtral(self) -> None:
+        adapter = MistralVLMAdapter()
+        assert "pixtral" in adapter.default_model.lower()
+
+    def test_ollama_default_model_is_vision_capable(self) -> None:
+        adapter = OllamaVLMAdapter()
+        # Modèle par défaut doit être un modèle vision (llava family).
+        assert "llava" in adapter.default_model.lower()
+
+
+# ──────────────────────────────────────────────────────────────────────
+# Intégration pipeline (utilisation comme StepExecutor)
+# ──────────────────────────────────────────────────────────────────────
+
+
+class TestVLMPipelineIntegration:
+    def test_used_as_pipeline_step(self, tmp_path: Path) -> None:
+        from picarones.pipeline.executor import PipelineExecutor
+        from picarones.pipeline.spec import PipelineSpec, PipelineStep
+        from picarones.domain.documents import DocumentRef
+
+        image_path = tmp_path / "doc01.png"
+        image_path.write_bytes(b"PNG_BYTES")
+
+        adapter = _StubVLMAdapter(response_text="VLM transcription")
+        executor = PipelineExecutor(adapter_resolver=lambda name: adapter)
+        spec = PipelineSpec(
+            name="vlm_pipeline",
+            initial_inputs=(ArtifactType.IMAGE,),
+            steps=(
+                PipelineStep(
+                    id="vlm",
+                    kind="vlm_transcription",
+                    adapter_name="stub_vlm",
+                    input_types=(ArtifactType.IMAGE,),
+                    output_types=(ArtifactType.RAW_TEXT,),
+                ),
+            ),
+        )
+        result = executor.run(
+            spec=spec,
+            document=DocumentRef(id="doc01"),
+            initial_inputs={
+                ArtifactType.IMAGE: _make_image_artifact(str(image_path)),
+            },
+            context=_make_context(),
+        )
+        assert result.succeeded
+        raw_text_artifacts = [
+            a for a in result.artifacts
+            if a.type == ArtifactType.RAW_TEXT
+        ]
+        assert len(raw_text_artifacts) == 1
+        out_path = Path(raw_text_artifacts[0].uri)
+        assert out_path.read_text(encoding="utf-8") == "VLM transcription"