feat(v2): add GenAI, Cohere, and Mistral providers

- Add instructor/v2/providers/genai/ with handlers for TOOLS, JSON modes
- Add instructor/v2/providers/cohere/ with handlers for TOOLS, JSON_SCHEMA, MD_JSON modes
- Add instructor/v2/providers/mistral/ with handlers for TOOLS, JSON_SCHEMA, MD_JSON modes
- Update instructor/v2/__init__.py with from_genai, from_cohere, from_mistral exports
- Add tests/v2/test_genai_integration.py
- Add tests/v2/test_cohere_handlers.py
- Add tests/v2/test_mistral_client.py and test_mistral_handlers.py

This PR was written by [Cursor](https://cursor.com)

Author: jxnl

instructor/v2/__init__.py

@@ -4,10 +4,11 @@
 
 Usage:
     from instructor import Mode
-    from instructor.v2 import from_anthropic, from_openai
+    from instructor.v2 import from_anthropic, from_openai, from_genai
 
     client = from_anthropic(anthropic_client, mode=Mode.TOOLS)
     client = from_openai(openai_client, mode=Mode.TOOLS)
+    client = from_genai(genai_client, mode=Mode.TOOLS)
 """
 
 from instructor import Mode, Provider
@@ -33,6 +34,21 @@
 except ImportError:
     from_openai = None  # type: ignore
 
+try:
+    from instructor.v2.providers.genai import from_genai
+except ImportError:
+    from_genai = None  # type: ignore
+
+try:
+    from instructor.v2.providers.cohere import from_cohere
+except ImportError:
+    from_cohere = None  # type: ignore
+
+try:
+    from instructor.v2.providers.mistral import from_mistral
+except ImportError:
+    from_mistral = None  # type: ignore
+
 __all__ = [
     # Re-exports from instructor
     "Mode",
@@ -51,5 +67,8 @@
     "ResponseParser",
     # Providers
     "from_anthropic",
+    "from_cohere",
+    "from_genai",
+    "from_mistral",
     "from_openai",
 ]

instructor/v2/providers/cohere/__init__.py

@@ -0,0 +1,8 @@
+"""v2 Cohere provider."""
+
+try:
+    from instructor.v2.providers.cohere.client import from_cohere
+except ImportError:
+    from_cohere = None  # type: ignore
+
+__all__ = ["from_cohere"]

instructor/v2/providers/cohere/client.py

@@ -0,0 +1,198 @@
+"""v2 Cohere client factory.
+
+Creates Instructor instances using v2 hierarchical registry system.
+Supports both Cohere V1 and V2 client APIs.
+"""
+
+from __future__ import annotations
+
+import inspect
+import json
+import time
+from collections.abc import Awaitable
+from typing import Any, cast, overload
+
+import cohere
+
+from instructor import AsyncInstructor, Instructor, Mode, Provider
+from instructor.v2.core.patch import patch_v2
+
+# Ensure handlers are registered (decorators auto-register on import)
+from instructor.v2.providers.cohere import handlers  # noqa: F401
+
+
+@overload
+def from_cohere(
+    client: cohere.Client,
+    mode: Mode = Mode.TOOLS,
+    **kwargs: Any,
+) -> Instructor: ...
+
+
+@overload
+def from_cohere(
+    client: cohere.ClientV2,
+    mode: Mode = Mode.TOOLS,
+    **kwargs: Any,
+) -> Instructor: ...
+
+
+@overload
+def from_cohere(
+    client: cohere.AsyncClient,
+    mode: Mode = Mode.TOOLS,
+    **kwargs: Any,
+) -> AsyncInstructor: ...
+
+
+@overload
+def from_cohere(
+    client: cohere.AsyncClientV2,
+    mode: Mode = Mode.TOOLS,
+    **kwargs: Any,
+) -> AsyncInstructor: ...
+
+
+def from_cohere(
+    client: cohere.Client | cohere.AsyncClient | cohere.ClientV2 | cohere.AsyncClientV2,
+    mode: Mode = Mode.TOOLS,
+    **kwargs: Any,
+) -> Instructor | AsyncInstructor:
+    """Create an Instructor instance from a Cohere client using v2 registry.
+
+    Args:
+        client: A Cohere client instance (V1 or V2, sync or async)
+        mode: The mode to use (defaults to Mode.TOOLS)
+        **kwargs: Additional keyword arguments to pass to the Instructor constructor
+
+    Returns:
+        An Instructor instance (sync or async depending on the client type)
+
+    Raises:
+        ModeError: If mode is not registered for Cohere
+        ClientError: If client is not a valid Cohere client instance
+
+    Examples:
+        >>> import cohere
+        >>> from instructor import Mode
+        >>> from instructor.v2.providers.cohere import from_cohere
+        >>>
+        >>> # V2 client (recommended)
+        >>> client = cohere.ClientV2()
+        >>> instructor_client = from_cohere(client, mode=Mode.TOOLS)
+        >>>
+        >>> # V1 client
+        >>> client = cohere.Client()
+        >>> instructor_client = from_cohere(client, mode=Mode.JSON_SCHEMA)
+    """
+    from instructor.v2.core.registry import mode_registry, normalize_mode
+
+    # Normalize provider-specific modes to generic modes
+    # COHERE_TOOLS -> TOOLS, COHERE_JSON_SCHEMA -> JSON_SCHEMA
+    normalized_mode = normalize_mode(Provider.COHERE, mode)
+
+    # Validate mode is registered
+    if not mode_registry.is_registered(Provider.COHERE, normalized_mode):
+        from instructor.core.exceptions import ModeError
+
+        available_modes = mode_registry.get_modes_for_provider(Provider.COHERE)
+        raise ModeError(
+            mode=mode.value,
+            provider=Provider.COHERE.value,
+            valid_modes=[m.value for m in available_modes],
+        )
+
+    # Use normalized mode for patching
+    mode = normalized_mode
+
+    # Validate client type
+    valid_client_types = (
+        cohere.Client,
+        cohere.AsyncClient,
+        cohere.ClientV2,
+        cohere.AsyncClientV2,
+    )
+
+    if not isinstance(client, valid_client_types):
+        from instructor.core.exceptions import ClientError
+
+        raise ClientError(
+            f"Client must be an instance of one of: {', '.join(t.__name__ for t in valid_client_types)}. "
+            f"Got: {type(client).__name__}"
+        )
+
+    # Detect client version for request formatting
+    if isinstance(client, (cohere.ClientV2, cohere.AsyncClientV2)):
+        client_version = "v2"
+    else:
+        client_version = "v1"
+
+    # region agent log
+    with open("/Users/jasonliu/dev/instructor/.cursor/debug.log", "a") as _log:
+        _log.write(
+            json.dumps(
+                {
+                    "sessionId": "debug-session",
+                    "runId": "streaming-pre",
+                    "hypothesisId": "H6",
+                    "location": "instructor/v2/providers/cohere/client.py:from_cohere",
+                    "message": "cohere_from_cohere_client_version",
+                    "data": {
+                        "client_type": type(client).__name__,
+                        "client_version": client_version,
+                        "mode": str(mode),
+                    },
+                    "timestamp": int(time.time() * 1000),
+                }
+            )
+            + "\n"
+        )
+    # endregion agent log
+    kwargs["_cohere_client_version"] = client_version
+
+    # Determine if async client
+    is_async = isinstance(client, (cohere.AsyncClient, cohere.AsyncClientV2))
+
+    if is_async:
+
+        async def async_wrapper(*args: Any, **call_kwargs: Any) -> Any:
+            if call_kwargs.pop("stream", False):
+                return client.chat_stream(*args, **call_kwargs)
+            result = client.chat(*args, **call_kwargs)
+            if inspect.isawaitable(result):
+                return await cast(Awaitable[Any], result)
+            return result
+
+        patched_create = patch_v2(
+            func=async_wrapper,
+            provider=Provider.COHERE,
+            mode=mode,
+        )
+
+        return AsyncInstructor(
+            client=client,
+            create=patched_create,
+            provider=Provider.COHERE,
+            mode=mode,
+            **kwargs,
+        )
+    else:
+
+        def sync_wrapper(*args: Any, **call_kwargs: Any) -> Any:
+            if call_kwargs.pop("stream", False):
+                return client.chat_stream(*args, **call_kwargs)
+            return client.chat(*args, **call_kwargs)
+
+        patched_create = patch_v2(
+            func=sync_wrapper,
+            provider=Provider.COHERE,
+            mode=mode,
+        )
+
+        return Instructor(
+            client=client,
+            create=patched_create,
+            provider=Provider.COHERE,
+            mode=mode,
+            **kwargs,
+        )