A-F-V · A-F-V · Mar 1, 2025 · Mar 1, 2025
diff --git a/instructor/client_anthropic.py b/instructor/client_anthropic.py
@@ -59,13 +59,11 @@ def from_anthropic(
         TypeError: If enable_prompt_caching is True and client is not Anthropic or AsyncAnthropic
         AssertionError: If mode is not ANTHROPIC_JSON or ANTHROPIC_TOOLS
     """
-    assert (
-        mode
-        in {
-            instructor.Mode.ANTHROPIC_JSON,
-            instructor.Mode.ANTHROPIC_TOOLS,
-        }
-    ), "Mode be one of {instructor.Mode.ANTHROPIC_JSON, instructor.Mode.ANTHROPIC_TOOLS}"
+    assert mode in {
+        instructor.Mode.ANTHROPIC_JSON,
+        instructor.Mode.ANTHROPIC_TOOLS,
+        instructor.Mode.ANTHROPIC_REASONING_TOOLS,
+    }, "Mode be one of {instructor.Mode.ANTHROPIC_JSON, instructor.Mode.ANTHROPIC_TOOLS, instructor.Mode.ANTHROPIC_REASONING_TOOLS}"
 
     assert isinstance(
         client,

diff --git a/instructor/function_calls.py b/instructor/function_calls.py
@@ -112,7 +112,7 @@ def from_response(
         Returns:
             cls (OpenAISchema): An instance of the class
         """
-        if mode == Mode.ANTHROPIC_TOOLS:
+        if mode == Mode.ANTHROPIC_TOOLS or mode == Mode.ANTHROPIC_REASONING_TOOLS:
             return cls.parse_anthropic_tools(completion, validation_context, strict)
 
         if mode == Mode.ANTHROPIC_JSON:

diff --git a/instructor/mode.py b/instructor/mode.py
@@ -14,6 +14,7 @@ class Mode(enum.Enum):
     MD_JSON = "markdown_json_mode"
     JSON_SCHEMA = "json_schema_mode"
     ANTHROPIC_TOOLS = "anthropic_tools"
+    ANTHROPIC_REASONING_TOOLS = "anthropic_reasoning_tools"
     ANTHROPIC_JSON = "anthropic_json"
     COHERE_TOOLS = "cohere_tools"
     VERTEXAI_TOOLS = "vertexai_tools"

diff --git a/instructor/multimodal.py b/instructor/multimodal.py
@@ -208,7 +208,9 @@ def to_openai(self) -> dict[str, Any]:
 class Audio(BaseModel):
     """Represents an audio that can be loaded from a URL or file path."""
 
-    source: str | Path = Field(description="URL or file path of the audio")  # noqa: UP007
+    source: str | Path = Field(
+        description="URL or file path of the audio"
+    )  # noqa: UP007
     data: Union[str, None] = Field(  # noqa: UP007
         None, description="Base64 encoded audio data", repr=False
     )
@@ -293,7 +295,11 @@ def convert_contents(
         elif isinstance(content, dict):
             converted_contents.append(content)
         elif isinstance(content, (Image, Audio)):
-            if mode in {Mode.ANTHROPIC_JSON, Mode.ANTHROPIC_TOOLS}:
+            if mode in {
+                Mode.ANTHROPIC_JSON,
+                Mode.ANTHROPIC_TOOLS,
+                Mode.ANTHROPIC_REASONING_TOOLS,
+            }:
                 converted_contents.append(content.to_anthropic())
             elif mode in {Mode.GEMINI_JSON, Mode.GEMINI_TOOLS}:
                 raise NotImplementedError("Gemini is not supported yet")
@@ -339,7 +345,9 @@ def is_image_params(x: Any) -> bool:
         }
         if autodetect_images:
             if isinstance(content, list):
-                new_content: list[str | dict[str, Any] | Image | Audio] = []  # noqa: UP007
+                new_content: list[str | dict[str, Any] | Image | Audio] = (
+                    []
+                )  # noqa: UP007
                 for item in content:
                     if isinstance(item, str):
                         new_content.append(Image.autodetect_safely(item))

diff --git a/instructor/process_response.py b/instructor/process_response.py
@@ -17,12 +17,12 @@
 from instructor.mode import Mode
 from instructor.dsl.iterable import IterableBase, IterableModel
 from instructor.dsl.parallel import (
-    ParallelBase, 
-    ParallelModel, 
-    handle_parallel_model, 
+    ParallelBase,
+    ParallelModel,
+    handle_parallel_model,
     get_types_array,
     VertexAIParallelBase,
-    VertexAIParallelModel
+    VertexAIParallelModel,
 )
 from instructor.dsl.partial import PartialBase
 from instructor.dsl.simple_type import AdapterBase, ModelAdapter, is_simple_type
@@ -357,6 +357,30 @@ def handle_anthropic_tools(
     return response_model, new_kwargs
 
 
+def handle_anthropic_reasoning_tools(
+    response_model: type[T], new_kwargs: dict[str, Any]
+) -> tuple[type[T], dict[str, Any]]:
+    # https://docs.anthropic.com/en/docs/build-with-claude/tool-use/overview#forcing-tool-use
+
+    response_model, new_kwargs = handle_anthropic_tools(response_model, new_kwargs)
+
+    # https://docs.anthropic.com/en/docs/build-with-claude/tool-use/overview#forcing-tool-use
+    # Reasoning does not allow forced tool use
+    new_kwargs["tool_choice"] = {"type": "auto"}
+
+    # But add a message recommending only to use the tools if they are relevant
+    implict_forced_tool_message = dedent(
+        f"""
+        Return only the tool call and no additional text.
+        """
+    )
+    new_kwargs["system"] = combine_system_messages(
+        new_kwargs.get("system"),
+        [{"type": "text", "text": implict_forced_tool_message}],
+    )
+    return response_model, new_kwargs
+
+
 def handle_anthropic_json(
     response_model: type[T], new_kwargs: dict[str, Any]
 ) -> tuple[type[T], dict[str, Any]]:
@@ -498,17 +522,17 @@ def handle_vertexai_parallel_tools(
     assert (
         new_kwargs.get("stream", False) is False
     ), "stream=True is not supported when using PARALLEL_TOOLS mode"
-    
+
     from instructor.client_vertexai import vertexai_process_response
-    
+
     # Extract concrete types before passing to vertexai_process_response
     model_types = list(get_types_array(response_model))
     contents, tools, tool_config = vertexai_process_response(new_kwargs, model_types)
-    
+
     new_kwargs["contents"] = contents
     new_kwargs["tools"] = tools
     new_kwargs["tool_config"] = tool_config
-    
+
     return VertexAIParallelModel(typehint=response_model), new_kwargs
 
 
@@ -612,7 +636,7 @@ def handle_cohere_tools(
 
 
 def handle_writer_tools(
-        response_model: type[T], new_kwargs: dict[str, Any]
+    response_model: type[T], new_kwargs: dict[str, Any]
 ) -> tuple[type[T], dict[str, Any]]:
     new_kwargs["tools"] = [
         {
@@ -732,6 +756,7 @@ def handle_response_model(
         Mode.MD_JSON: lambda rm, nk: handle_json_modes(rm, nk, Mode.MD_JSON),  # type: ignore
         Mode.JSON_SCHEMA: lambda rm, nk: handle_json_modes(rm, nk, Mode.JSON_SCHEMA),  # type: ignore
         Mode.ANTHROPIC_TOOLS: handle_anthropic_tools,
+        Mode.ANTHROPIC_REASONING_TOOLS: handle_anthropic_reasoning_tools,
         Mode.ANTHROPIC_JSON: handle_anthropic_json,
         Mode.COHERE_JSON_SCHEMA: handle_cohere_json_schema,
         Mode.COHERE_TOOLS: handle_cohere_tools,

diff --git a/instructor/reask.py b/instructor/reask.py
@@ -336,6 +336,7 @@ def handle_reask_kwargs(
 
     functions = {
         Mode.ANTHROPIC_TOOLS: reask_anthropic_tools,
+        Mode.ANTHROPIC_REASONING_TOOLS: reask_anthropic_tools,
         Mode.ANTHROPIC_JSON: reask_anthropic_json,
         Mode.COHERE_TOOLS: reask_cohere_tools,
         Mode.COHERE_JSON_SCHEMA: reask_cohere_tools,  # Same Function

diff --git a/tests/llm/test_anthropic/test_reasoning.py b/tests/llm/test_anthropic/test_reasoning.py
@@ -3,19 +3,23 @@
 import instructor
 from pydantic import BaseModel
 from itertools import product
-from .util import models, modes
 from anthropic.types.message import Message
 
 
 class Answer(BaseModel):
     answer: float
 
 
-def test_reasoning():
+modes = [
+    instructor.Mode.ANTHROPIC_REASONING_TOOLS,
+    instructor.Mode.ANTHROPIC_JSON,
+]
+
+
+@pytest.mark.parametrize("mode", modes)
+def test_reasoning(mode):
     anthropic_client = anthropic.Anthropic()
-    client = instructor.from_anthropic(
-        anthropic_client, mode=instructor.Mode.ANTHROPIC_JSON
-    )
+    client = instructor.from_anthropic(anthropic_client, mode=mode)
     response = client.chat.completions.create(
         model="claude-3-7-sonnet-latest",
         response_model=Answer,