diff --git a/dspy/adapters/base.py b/dspy/adapters/base.py
index 9ad6d12565..1237685b90 100644
--- a/dspy/adapters/base.py
+++ b/dspy/adapters/base.py
@@ -1,10 +1,13 @@
+import logging
 from typing import TYPE_CHECKING, Any, Optional, Type
 
-from dspy.adapters.types import History
+from dspy.adapters.types import BaseType, History
 from dspy.adapters.types.base_type import split_message_content_for_custom_types
 from dspy.signatures.signature import Signature
 from dspy.utils.callback import BaseCallback, with_callbacks
 
+logger = logging.getLogger(__name__)
+
 if TYPE_CHECKING:
     from dspy.clients.lm import LM
 
@@ -22,20 +25,41 @@ def __init_subclass__(cls, **kwargs) -> None:
 
     def _call_post_process(self, outputs: list[dict[str, Any]], signature: Type[Signature]) -> list[dict[str, Any]]:
         values = []
+        output_field_name, field_info = next(iter(signature.output_fields.items()))
+        annotation = field_info.annotation
 
         for output in outputs:
             output_logprobs = None
-
             if isinstance(output, dict):
-                output, output_logprobs = output["text"], output["logprobs"]
-
-            value = self.parse(signature, output)
+                if "text" in output:
+                    output, output_logprobs = output["text"], output.get("logprobs")
+                elif "content" in output:
+                    output_content = output["content"]
+                    if isinstance(output_content, list) and output_content and "text" in output_content[0]:
+                        output = output_content[0]["text"]
+                    else:
+                        output = ""
+                    output_logprobs = None
+                else:
+                    output = str(output)
+                    output_logprobs = None
+            try:
+                if issubclass(annotation, BaseType):
+                    try:
+                        parsed = annotation.parse(output)
+                        value = {output_field_name: parsed}
+                    except Exception as e:
+                        logger.warning(f"Output is not of expected annotation field '{output_field_name}': {e}")
+                        continue
+                else:
+                    value = self.parse(signature, output)
+            except TypeError:
+                value = self.parse(signature, output)
 
             if output_logprobs is not None:
                 value["logprobs"] = output_logprobs
-
             values.append(value)
-
+    
         return values
 
     def __call__(
@@ -48,6 +72,13 @@ def __call__(
     ) -> list[dict[str, Any]]:
         inputs = self.format(signature, demos, inputs)
 
+        if getattr(lm, "model_type", None) == "responses":
+            for msg in inputs:
+                if msg["role"] == "user" and isinstance(msg["content"], list):
+                    for block in msg["content"]:
+                        if block.get("type") == "text":
+                            block["type"] = "input_text"
+
         outputs = lm(messages=inputs, **lm_kwargs)
         return self._call_post_process(outputs, signature)
 
diff --git a/dspy/adapters/types/base_type.py b/dspy/adapters/types/base_type.py
index f2983ef463..9443371e25 100644
--- a/dspy/adapters/types/base_type.py
+++ b/dspy/adapters/types/base_type.py
@@ -28,6 +28,10 @@ def format(self) -> list[dict[str, Any]]:
 
     def format(self) -> list[dict[str, Any]]:
         raise NotImplementedError
+    
+    @classmethod
+    def parse(cls, raw: Any) -> "BaseType":
+        return cls(**raw)
 
     @pydantic.model_serializer()
     def serialize_model(self):
diff --git a/dspy/adapters/types/image.py b/dspy/adapters/types/image.py
index 693b407fb6..bc3cf12c46 100644
--- a/dspy/adapters/types/image.py
+++ b/dspy/adapters/types/image.py
@@ -33,8 +33,29 @@ def format(self) -> Union[list[dict[str, Any]], str]:
             image_url = encode_image(self.url)
         except Exception as e:
             raise ValueError(f"Failed to format image for DSPy: {e}")
-        return [{"type": "image_url", "image_url": {"url": image_url}}]
+        if isinstance(image_url, str):
+            return [{"type": "input_image", "image_url": image_url}]
+        else:
+            return [{"type": "input_image", "image_url": {"url": image_url}}]
 
+    @classmethod
+    def parse(cls, raw: Any) -> "Image":
+        if isinstance(raw, dict):
+            if "result" in raw:
+                b64 = raw["result"]
+            else:
+                raise TypeError("Input for parsing is missing 'result'")
+        elif hasattr(raw, "result"):
+            b64 = getattr(raw, "result")
+        elif hasattr(raw, "data"):
+            b64 = raw.data[0].b64_json
+        elif isinstance(raw, str):
+            b64 = raw
+        else:
+            raise TypeError(f"Unsupported type {type(raw)} for Image.parse")
+        uri = b64 if b64.startswith("data:") else f"data:image/png;base64,{b64}"
+        return cls(url=uri)
+    
     @pydantic.model_validator(mode="before")
     @classmethod
     def validate_input(cls, values):
diff --git a/dspy/clients/base_lm.py b/dspy/clients/base_lm.py
index 0c3ae2ee76..e42b9ade84 100644
--- a/dspy/clients/base_lm.py
+++ b/dspy/clients/base_lm.py
@@ -50,7 +50,20 @@ def __init__(self, model, model_type="chat", temperature=0.0, max_tokens=1000, c
 
     def _process_lm_response(self, response, prompt, messages, **kwargs):
         merged_kwargs = {**self.kwargs, **kwargs}
-        if merged_kwargs.get("logprobs"):
+        if hasattr(response, "output") or (isinstance(response, dict) and "output" in response):
+            output_items = response.output if hasattr(response, "output") else response["output"]
+            output_items = list(output_items)
+            if any(not (hasattr(item, "content") or (isinstance(item, dict) and "content" in item)) for item in output_items):
+                outputs = output_items
+            else:
+                outputs = []
+                for item in output_items:
+                    content_list = item.get("content", []) if isinstance(item, dict) else getattr(item, "content", [])
+                    for c in content_list:
+                        if (isinstance(c, dict) and c.get("type") == "output_text") or (hasattr(c, "type") and getattr(c, "type", None) == "output_text"):
+                            text_val = c.get("text") if isinstance(c, dict) else getattr(c, "text", "")
+                            outputs.append(text_val)
+        elif merged_kwargs.get("logprobs"):
             outputs = [
                 {
                     "text": c.message.content if hasattr(c, "message") else c["text"],
@@ -133,7 +146,7 @@ def copy(self, **kwargs):
         return new_instance
 
     def inspect_history(self, n: int = 1):
-        return inspect_history(self.history, n)
+        return pretty_print_history(self.history, n)
 
     def update_global_history(self, entry):
         if settings.disable_history:
diff --git a/dspy/clients/lm.py b/dspy/clients/lm.py
index 384960a114..ed985b62cd 100644
--- a/dspy/clients/lm.py
+++ b/dspy/clients/lm.py
@@ -29,7 +29,7 @@ class LM(BaseLM):
     def __init__(
         self,
         model: str,
-        model_type: Literal["chat", "text"] = "chat",
+        model_type: Literal["chat", "text", "responses"] = "chat",
         temperature: float = 0.0,
         max_tokens: int = 4000,
         cache: bool = True,
@@ -120,8 +120,15 @@ def forward(self, prompt=None, messages=None, **kwargs):
 
         messages = messages or [{"role": "user", "content": prompt}]
         kwargs = {**self.kwargs, **kwargs}
-
-        completion = litellm_completion if self.model_type == "chat" else litellm_text_completion
+        
+
+        if self.model_type == "chat":
+            completion = litellm_completion
+        elif self.model_type == "text":
+            completion = litellm_text_completion
+        elif self.model_type == "responses":
+            completion = litellm_responses_completion
+ 
         completion, litellm_cache_args = self._get_cached_completion_fn(completion, cache, enable_memory_cache)
 
         results = completion(
@@ -129,15 +136,25 @@ def forward(self, prompt=None, messages=None, **kwargs):
             num_retries=self.num_retries,
             cache=litellm_cache_args,
         )
+        if self.model_type != "responses":
+            if any(c.finish_reason == "length" for c in results["choices"]):
+                logger.warning(
+                    f"LM response was truncated due to exceeding max_tokens={self.kwargs['max_tokens']}. "
+                    "You can inspect the latest LM interactions with `dspy.inspect_history()`. "
+                    "To avoid truncation, consider passing a larger max_tokens when setting up dspy.LM. "
+                    f"You may also consider increasing the temperature (currently {self.kwargs['temperature']}) "
+                    " if the reason for truncation is repetition."
+                )
+        else:
+            if results.get("truncation") == "enabled":
+                logger.warning(
+                    f"LM response was truncated due to exceeding max_tokens={self.kwargs['max_tokens']}. "
+                    "You can inspect the latest LM interactions with `dspy.inspect_history()`. "
+                    "To avoid truncation, consider passing a larger max_tokens when setting up dspy.LM. "
+                    f"You may also consider increasing the temperature (currently {self.kwargs['temperature']}) "
+                    " if the reason for truncation is repetition."
+                )
 
-        if any(c.finish_reason == "length" for c in results["choices"]):
-            logger.warning(
-                f"LM response was truncated due to exceeding max_tokens={self.kwargs['max_tokens']}. "
-                "You can inspect the latest LM interactions with `dspy.inspect_history()`. "
-                "To avoid truncation, consider passing a larger max_tokens when setting up dspy.LM. "
-                f"You may also consider increasing the temperature (currently {self.kwargs['temperature']}) "
-                " if the reason for truncation is repetition."
-            )
 
         if not getattr(results, "cache_hit", False) and dspy.settings.usage_tracker and hasattr(results, "usage"):
             settings.usage_tracker.add_usage(self.model, dict(results.usage))
@@ -151,7 +168,12 @@ async def aforward(self, prompt=None, messages=None, **kwargs):
         messages = messages or [{"role": "user", "content": prompt}]
         kwargs = {**self.kwargs, **kwargs}
 
-        completion = alitellm_completion if self.model_type == "chat" else alitellm_text_completion
+        if self.model_type == "chat":
+            completion = alitellm_completion
+        elif self.model_type == "text":
+            completion = alitellm_text_completion
+        elif self.model_type == "responses":
+            completion = alitellm_responses_completion
         completion, litellm_cache_args = self._get_cached_completion_fn(completion, cache, enable_memory_cache)
 
         results = await completion(
@@ -160,14 +182,24 @@ async def aforward(self, prompt=None, messages=None, **kwargs):
             cache=litellm_cache_args,
         )
 
-        if any(c.finish_reason == "length" for c in results["choices"]):
-            logger.warning(
-                f"LM response was truncated due to exceeding max_tokens={self.kwargs['max_tokens']}. "
-                "You can inspect the latest LM interactions with `dspy.inspect_history()`. "
-                "To avoid truncation, consider passing a larger max_tokens when setting up dspy.LM. "
-                f"You may also consider increasing the temperature (currently {self.kwargs['temperature']}) "
-                " if the reason for truncation is repetition."
-            )
+        if self.model_type != "responses":
+            if any(c.finish_reason == "length" for c in results["choices"]):
+                logger.warning(
+                    f"LM response was truncated due to exceeding max_tokens={self.kwargs['max_tokens']}. "
+                    "You can inspect the latest LM interactions with `dspy.inspect_history()`. "
+                    "To avoid truncation, consider passing a larger max_tokens when setting up dspy.LM. "
+                    f"You may also consider increasing the temperature (currently {self.kwargs['temperature']}) "
+                    " if the reason for truncation is repetition."
+                )
+        else:
+            if results.get("truncation") == "enabled":
+                logger.warning(
+                    f"LM response was truncated due to exceeding max_tokens={self.kwargs['max_tokens']}. "
+                    "You can inspect the latest LM interactions with `dspy.inspect_history()`. "
+                    "To avoid truncation, consider passing a larger max_tokens when setting up dspy.LM. "
+                    f"You may also consider increasing the temperature (currently {self.kwargs['temperature']}) "
+                    " if the reason for truncation is repetition."
+                )
 
         if not getattr(results, "cache_hit", False) and dspy.settings.usage_tracker and hasattr(results, "usage"):
             settings.usage_tracker.add_usage(self.model, dict(results.usage))
@@ -373,3 +405,41 @@ async def alitellm_text_completion(request: Dict[str, Any], num_retries: int, ca
         retry_strategy="exponential_backoff_retry",
         **request,
     )
+
+def litellm_responses_completion(request: Dict[str, Any], num_retries: int, cache: Optional[Dict[str, Any]] = None):
+    cache = cache or {"no-cache": True, "no-store": True}
+    if "messages" in request:
+        content_blocks = []
+        for msg in request.pop("messages"):
+            c = msg.get("content")
+            if isinstance(c, str):
+                content_blocks.append({"type": "input_text", "text": c})
+            elif isinstance(c, list):
+                content_blocks.extend(c)
+        request["input"] = [{"role": msg.get("role", "user"), "content": content_blocks}]
+    
+    return litellm.responses(
+        cache=cache,
+        num_retries=num_retries,
+        retry_strategy="exponential_backoff_retry",
+        **request,
+    )
+
+
+async def alitellm_responses_completion(request: Dict[str, Any], num_retries: int, cache: Optional[Dict[str, Any]] = None):
+    cache = cache or {"no-cache": True, "no-store": True}
+    if "messages" in request:
+        content_blocks = []
+        for msg in request.pop("messages"):
+            c = msg.get("content")
+            if isinstance(c, str):
+                content_blocks.append({"type": "input_text", "text": c})
+            elif isinstance(c, list):
+                content_blocks.extend(c)
+        request["input"] = [{"role": msg.get("role", "user"), "content": content_blocks}]
+    return await litellm.aresponses(
+        cache=cache,
+        num_retries=num_retries,
+        retry_strategy="exponential_backoff_retry",
+        **request,
+    )
\ No newline at end of file
diff --git a/dspy/utils/inspect_history.py b/dspy/utils/inspect_history.py
index 16baefd303..032c01f890 100644
--- a/dspy/utils/inspect_history.py
+++ b/dspy/utils/inspect_history.py
@@ -41,10 +41,26 @@ def pretty_print_history(history, n: int = 1):
                             else:
                                 image_str = f"<image_url: {c['image_url']['url']}>"
                             print(_blue(image_str.strip()))
+                        elif c["type"] == "input_audio":
+                            audio_format = c["input_audio"]["format"]
+                            len_audio = len(c["input_audio"]["data"])
+                            audio_str = f"<audio format='{audio_format}' base64-encoded, length={len_audio}>"
+                            print(_blue(audio_str.strip()))
             print("\n")
 
         print(_red("Response:"))
-        print(_green(outputs[0].strip()))
+        out = outputs[0]
+        if isinstance(out, str):
+            print(_green(out.strip()))
+        elif hasattr(out, "result") and isinstance(out.result, str):
+            b64 = out.result
+            if b64.startswith("data:"):
+                head, b64data = b64.split(",", 1)
+                print(_green(f"<Image output: {head}base64,<IMAGE_BASE_64_ENCODED({len(b64data)})>>"))
+            else:
+                print(_green(f"<Image output: base64,<IMAGE_BASE_64_ENCODED({len(b64)})>>"))
+        else:
+            print(_green(f"<Non-string output: {repr(out)}>"))
 
         if len(outputs) > 1:
             choices_text = f" \t (and {len(outputs) - 1} other completions)"
diff --git a/tests/adapters/test_chat_adapter.py b/tests/adapters/test_chat_adapter.py
index d25000e4ef..0e7dda1de4 100644
--- a/tests/adapters/test_chat_adapter.py
+++ b/tests/adapters/test_chat_adapter.py
@@ -219,7 +219,7 @@ class MySignature(dspy.Signature):
     assert user_message_content[2]["type"] == "text"
 
     # Assert that the image is formatted correctly
-    expected_image_content = {"type": "image_url", "image_url": {"url": "https://example.com/image.jpg"}}
+    expected_image_content = {"type": "input_image", "image_url": "https://example.com/image.jpg"}
     assert expected_image_content in user_message_content
 
 
@@ -245,9 +245,10 @@ class MySignature(dspy.Signature):
     # 1 system message, 2 few shot examples (1 user and assistant message for each example), 1 user message
     assert len(messages) == 6
 
-    assert {"type": "image_url", "image_url": {"url": "https://example.com/image1.jpg"}} in messages[1]["content"]
-    assert {"type": "image_url", "image_url": {"url": "https://example.com/image2.jpg"}} in messages[3]["content"]
-    assert {"type": "image_url", "image_url": {"url": "https://example.com/image3.jpg"}} in messages[5]["content"]
+    assert {"type": "input_image", "image_url": "https://example.com/image1.jpg"} in messages[1]["content"]
+    assert {"type": "input_image", "image_url": "https://example.com/image2.jpg"} in messages[3]["content"]
+    assert {"type": "input_image", "image_url": "https://example.com/image3.jpg"} in messages[5]["content"]
+
 
 
 def test_chat_adapter_formats_image_with_nested_images():
@@ -268,9 +269,11 @@ class MySignature(dspy.Signature):
     adapter = dspy.ChatAdapter()
     messages = adapter.format(MySignature, [], {"image": image_wrapper})
 
-    expected_image1_content = {"type": "image_url", "image_url": {"url": "https://example.com/image1.jpg"}}
-    expected_image2_content = {"type": "image_url", "image_url": {"url": "https://example.com/image2.jpg"}}
-    expected_image3_content = {"type": "image_url", "image_url": {"url": "https://example.com/image3.jpg"}}
+    expected_image1_content = {"type": "input_image", "image_url": "https://example.com/image1.jpg"}
+    expected_image2_content = {"type": "input_image", "image_url": "https://example.com/image2.jpg"}
+    expected_image3_content = {"type": "input_image", "image_url": "https://example.com/image3.jpg"}
+
+
 
     assert expected_image1_content in messages[1]["content"]
     assert expected_image2_content in messages[1]["content"]
@@ -305,12 +308,14 @@ class MySignature(dspy.Signature):
     assert len(messages) == 4
 
     # Image information in the few-shot example's user message
-    expected_image1_content = {"type": "image_url", "image_url": {"url": "https://example.com/image1.jpg"}}
-    expected_image2_content = {"type": "image_url", "image_url": {"url": "https://example.com/image2.jpg"}}
-    expected_image3_content = {"type": "image_url", "image_url": {"url": "https://example.com/image3.jpg"}}
+    expected_image1_content = {"type": "input_image", "image_url": "https://example.com/image1.jpg"}
+    expected_image2_content = {"type": "input_image", "image_url": "https://example.com/image2.jpg"}
+    expected_image3_content = {"type": "input_image", "image_url": "https://example.com/image3.jpg"}
+
+
     assert expected_image1_content in messages[1]["content"]
     assert expected_image2_content in messages[1]["content"]
     assert expected_image3_content in messages[1]["content"]
 
     # The query image is formatted in the last user message
-    assert {"type": "image_url", "image_url": {"url": "https://example.com/image4.jpg"}} in messages[-1]["content"]
+    assert {"type": "input_image", "image_url": "https://example.com/image4.jpg"} in messages[-1]["content"]
diff --git a/tests/adapters/test_json_adapter.py b/tests/adapters/test_json_adapter.py
index 6cd185203d..e81e3156d7 100644
--- a/tests/adapters/test_json_adapter.py
+++ b/tests/adapters/test_json_adapter.py
@@ -242,7 +242,7 @@ class MySignature(dspy.Signature):
     assert user_message_content[2]["type"] == "text"
 
     # Assert that the image is formatted correctly
-    expected_image_content = {"type": "image_url", "image_url": {"url": "https://example.com/image.jpg"}}
+    expected_image_content = {"type": "input_image", "image_url": "https://example.com/image.jpg"}
     assert expected_image_content in user_message_content
 
 
@@ -268,9 +268,10 @@ class MySignature(dspy.Signature):
     # 1 system message, 2 few shot examples (1 user and assistant message for each example), 1 user message
     assert len(messages) == 6
 
-    assert {"type": "image_url", "image_url": {"url": "https://example.com/image1.jpg"}} in messages[1]["content"]
-    assert {"type": "image_url", "image_url": {"url": "https://example.com/image2.jpg"}} in messages[3]["content"]
-    assert {"type": "image_url", "image_url": {"url": "https://example.com/image3.jpg"}} in messages[5]["content"]
+    assert {"type": "input_image", "image_url": "https://example.com/image1.jpg"} in messages[1]["content"]
+    assert {"type": "input_image", "image_url": "https://example.com/image2.jpg"} in messages[3]["content"]
+    assert {"type": "input_image", "image_url": "https://example.com/image3.jpg"} in messages[5]["content"]
+
 
 
 def test_json_adapter_formats_image_with_nested_images():
@@ -291,9 +292,9 @@ class MySignature(dspy.Signature):
     adapter = dspy.JSONAdapter()
     messages = adapter.format(MySignature, [], {"image": image_wrapper})
 
-    expected_image1_content = {"type": "image_url", "image_url": {"url": "https://example.com/image1.jpg"}}
-    expected_image2_content = {"type": "image_url", "image_url": {"url": "https://example.com/image2.jpg"}}
-    expected_image3_content = {"type": "image_url", "image_url": {"url": "https://example.com/image3.jpg"}}
+    expected_image1_content = {"type": "input_image", "image_url": "https://example.com/image1.jpg"}
+    expected_image2_content = {"type": "input_image", "image_url": "https://example.com/image2.jpg"}
+    expected_image3_content = {"type": "input_image", "image_url": "https://example.com/image3.jpg"}
 
     assert expected_image1_content in messages[1]["content"]
     assert expected_image2_content in messages[1]["content"]
@@ -328,12 +329,12 @@ class MySignature(dspy.Signature):
     assert len(messages) == 4
 
     # Image information in the few-shot example's user message
-    expected_image1_content = {"type": "image_url", "image_url": {"url": "https://example.com/image1.jpg"}}
-    expected_image2_content = {"type": "image_url", "image_url": {"url": "https://example.com/image2.jpg"}}
-    expected_image3_content = {"type": "image_url", "image_url": {"url": "https://example.com/image3.jpg"}}
+    expected_image1_content = {"type": "input_image", "image_url": "https://example.com/image1.jpg"}
+    expected_image2_content = {"type": "input_image", "image_url": "https://example.com/image2.jpg"}
+    expected_image3_content = {"type": "input_image", "image_url": "https://example.com/image3.jpg"}
     assert expected_image1_content in messages[1]["content"]
     assert expected_image2_content in messages[1]["content"]
     assert expected_image3_content in messages[1]["content"]
 
     # The query image is formatted in the last user message
-    assert {"type": "image_url", "image_url": {"url": "https://example.com/image4.jpg"}} in messages[-1]["content"]
+    assert {"type": "input_image", "image_url": "https://example.com/image4.jpg"} in messages[-1]["content"]
diff --git a/tests/clients/test_lm.py b/tests/clients/test_lm.py
index e1ff625d8f..b89ab37cc2 100644
--- a/tests/clients/test_lm.py
+++ b/tests/clients/test_lm.py
@@ -6,6 +6,7 @@
 import pydantic
 import pytest
 from litellm.utils import Choices, Message, ModelResponse
+from litellm.types.llms.openai import ResponsesAPIResponse, ResponseAPIUsage
 from openai import RateLimitError
 
 import dspy
@@ -125,7 +126,7 @@ def test_text_lms_can_be_queried(litellm_test_server):
 def test_lm_calls_support_callables(litellm_test_server):
     api_base, _ = litellm_test_server
 
-    with mock.patch("litellm.completion", autospec=True, wraps=litellm.completion) as spy_completion:
+    with mock.patch("litellm.completion", autospec=True, wraps=litellm.completion) as dspy_completion:
 
         def azure_ad_token_provider(*args, **kwargs):
             return None
@@ -140,8 +141,8 @@ def azure_ad_token_provider(*args, **kwargs):
 
         lm_with_callable("Query")
 
-        spy_completion.assert_called_once()
-        call_args = spy_completion.call_args.kwargs
+        dspy_completion.assert_called_once()
+        call_args = dspy_completion.call_args.kwargs
         assert call_args["model"] == "openai/dspy-test-model"
         assert call_args["api_base"] == api_base
         assert call_args["api_key"] == "fakekey"
@@ -374,3 +375,64 @@ async def test_async_lm_call_with_cache(tmp_path):
         assert mock_alitellm_completion.call_count == 2
 
     dspy.cache = original_cache
+
+def make_response(output_blocks, *, model="openai/dspy-test-model", tools=None):
+    return ResponsesAPIResponse(
+        id="resp_1",
+        created_at=0.0,
+        error=None,
+        incomplete_details=None,
+        instructions=None,
+        model=model,
+        object="response",
+        output=output_blocks,
+        metadata = {},
+        parallel_tool_calls=bool(tools),
+        temperature=1.0,
+        tool_choice="auto",
+        tools=tools or [],
+        top_p=1.0,
+        max_output_tokens=None,
+        previous_response_id=None,
+        reasoning=None,
+        status="completed",
+        text=None,
+        truncation="disabled",
+        usage=ResponseAPIUsage(input_tokens=1, output_tokens=1, total_tokens=2),
+        user=None,
+    )
+
+
+def test_responses_lms_can_be_queried(litellm_test_server):
+    api_base, _ = litellm_test_server
+    expected_text = "This is a test answer from responses API."
+
+    api_response = make_response(
+        output_blocks=[
+            {
+                "id": "msg_1",
+                "type": "message",
+                "role": "assistant",
+                "status": "completed",
+                "content": [
+                    {"type": "output_text", "text": expected_text, "annotations": []}
+                ],
+            }
+        ]
+    )
+
+    with mock.patch("litellm.responses", autospec=True) as dspy_responses:
+        dspy_responses.return_value = api_response
+
+        lm = dspy.LM(
+            model="openai/dspy-test-model",
+            api_base=api_base,
+            api_key="fakekey",
+            model_type="responses",
+            cache=False,
+            cache_in_memory=False,
+        )
+        assert lm("openai query") == [expected_text]
+
+        dspy_responses.assert_called_once()
+        assert dspy_responses.call_args.kwargs["model"] == "openai/dspy-test-model"
diff --git a/tests/signatures/test_adapter_image.py b/tests/signatures/test_adapter_image.py
index 9223b2bf08..b75d5de510 100644
--- a/tests/signatures/test_adapter_image.py
+++ b/tests/signatures/test_adapter_image.py
@@ -37,30 +37,29 @@ def sample_dspy_image_no_download():
     return dspy.Image.from_url("https://images.dog.ceo/breeds/dane-great/n02109047_8912.jpg", download=False)
 
 
-def count_messages_with_image_url_pattern(messages):
-    pattern = {"type": "image_url", "image_url": {"url": lambda x: isinstance(x, str)}}
+def count_messages_with_input_image_pattern(messages):
+    pattern = {"type": "input_image", "image_url": lambda x: isinstance(x, str)}
+
+    def check_pattern(obj, pattern):
+        if isinstance(pattern, dict):
+            if not isinstance(obj, dict):
+                return False
+            return all(k in obj and check_pattern(obj[k], v) for k, v in pattern.items())
+        if callable(pattern):
+            return pattern(obj)
+        return obj == pattern
+
+    def count_patterns(obj, pattern):
+        count = 0
+        if check_pattern(obj, pattern):
+            count += 1
+        if isinstance(obj, dict):
+            count += sum(count_patterns(v, pattern) for v in obj.values())
+        if isinstance(obj, (list, tuple)):
+            count += sum(count_patterns(v, pattern) for v in obj)
+        return count
 
     try:
-
-        def check_pattern(obj, pattern):
-            if isinstance(pattern, dict):
-                if not isinstance(obj, dict):
-                    return False
-                return all(k in obj and check_pattern(obj[k], v) for k, v in pattern.items())
-            if callable(pattern):
-                return pattern(obj)
-            return obj == pattern
-
-        def count_patterns(obj, pattern):
-            count = 0
-            if check_pattern(obj, pattern):
-                count += 1
-            if isinstance(obj, dict):
-                count += sum(count_patterns(v, pattern) for v in obj.values())
-            if isinstance(obj, (list, tuple)):
-                count += sum(count_patterns(v, pattern) for v in obj)
-            return count
-
         return count_patterns(messages, pattern)
     except Exception:
         return 0
@@ -123,7 +122,7 @@ def test_basic_image_operations(test_case):
     # Check result based on output field name
     output_field = next(f for f in ["probabilities", "generated_code", "bboxes", "captions"] if hasattr(result, f))
     assert getattr(result, output_field) == test_case["expected"][test_case["key_output"]]
-    assert count_messages_with_image_url_pattern(lm.history[-1]["messages"]) == 1
+    assert count_messages_with_input_image_pattern(lm.history[-1]["messages"]) == 1
 
 
 @pytest.mark.parametrize(
@@ -157,7 +156,7 @@ def test_image_input_formats(
 
     result = predictor(image=actual_input, class_labels=["dog", "cat", "bird"])
     assert result.probabilities == expected["probabilities"]
-    assert count_messages_with_image_url_pattern(lm.history[-1]["messages"]) == 1
+    assert count_messages_with_input_image_pattern(lm.history[-1]["messages"]) == 1
 
 
 def test_predictor_save_load(sample_url, sample_pil_image):
@@ -178,7 +177,7 @@ def test_predictor_save_load(sample_url, sample_pil_image):
         loaded_predictor.load(temp_file.name)
 
     loaded_predictor(image=dspy.Image.from_url("https://example.com/dog.jpg"))
-    assert count_messages_with_image_url_pattern(lm.history[-1]["messages"]) == 2
+    assert count_messages_with_input_image_pattern(lm.history[-1]["messages"]) == 2
     assert "<DSPY_IMAGE_START>" not in str(lm.history[-1]["messages"])
 
 
@@ -209,7 +208,7 @@ class ComplexTypeSignature(dspy.Signature):
 
     result = loaded_predictor(**examples[0].inputs())
     assert result.caption == "A list of images"
-    assert str(lm.history[-1]["messages"]).count("'url'") == 4
+    assert count_messages_with_input_image_pattern(lm.history[-1]["messages"]) == 4
     assert "<DSPY_IMAGE_START>" not in str(lm.history[-1]["messages"])
 
 
@@ -281,7 +280,7 @@ def test_save_load_complex_types(test_case):
         assert getattr(result, key) == value
 
     # Verify correct number of image URLs in messages
-    assert count_messages_with_image_url_pattern(lm.history[-1]["messages"]) == test_case["expected_image_urls"]
+    assert count_messages_with_input_image_pattern(lm.history[-1]["messages"]) == test_case["expected_image_urls"]
     assert "<DSPY_IMAGE_START>" not in str(lm.history[-1]["messages"])
 
 
@@ -322,7 +321,7 @@ class PydanticSignature(dspy.Signature):
 
     # Verify output matches expected
     assert result.output == "Multiple photos"
-    assert count_messages_with_image_url_pattern(lm.history[-1]["messages"]) == 4
+    assert count_messages_with_input_image_pattern(lm.history[-1]["messages"]) == 4
     assert "<DSPY_IMAGE_START>" not in str(lm.history[-1]["messages"])
 
 
@@ -336,7 +335,7 @@ class OptionalImageSignature(dspy.Signature):
     predictor, lm = setup_predictor(OptionalImageSignature, {"output": "Hello"})
     result = predictor(image=None)
     assert result.output == "Hello"
-    assert count_messages_with_image_url_pattern(lm.history[-1]["messages"]) == 0
+    assert count_messages_with_input_image_pattern(lm.history[-1]["messages"]) == 0
 
 
 def test_pdf_url_support():
@@ -359,7 +358,7 @@ class PDFSignature(dspy.Signature):
     result = predictor(document=pdf_image)
 
     assert result.summary == "This is a dummy PDF"
-    assert count_messages_with_image_url_pattern(lm.history[-1]["messages"]) == 1
+    assert count_messages_with_input_image_pattern(lm.history[-1]["messages"]) == 1
 
     # Ensure the URL was properly expanded in messages
     messages_str = str(lm.history[-1]["messages"])
@@ -437,7 +436,7 @@ class FilePDFSignature(dspy.Signature):
         result = predictor(document=pdf_image)
 
         assert result.summary == "This is a PDF from file"
-        assert count_messages_with_image_url_pattern(lm.history[-1]["messages"]) == 1
+        assert count_messages_with_input_image_pattern(lm.history[-1]["messages"]) == 1
     finally:
         # Clean up the temporary file
         try:
@@ -451,13 +450,31 @@ def test_image_repr():
     url_image = dspy.Image.from_url("https://example.com/dog.jpg", download=False)
     assert str(url_image) == (
         "<<CUSTOM-TYPE-START-IDENTIFIER>>"
-        "[{'type': 'image_url', 'image_url': {'url': 'https://example.com/dog.jpg'}}]"
+        "[{'type': 'input_image', 'image_url': 'https://example.com/dog.jpg'}]"
         "<<CUSTOM-TYPE-END-IDENTIFIER>>"
     )
     assert repr(url_image) == "Image(url='https://example.com/dog.jpg')"
 
     sample_pil = PILImage.new("RGB", (60, 30), color="red")
     pil_image = dspy.Image.from_PIL(sample_pil)
-    assert str(pil_image).startswith("<<CUSTOM-TYPE-START-IDENTIFIER>>[{'type': 'image_url',")
+    assert str(pil_image).startswith("<<CUSTOM-TYPE-START-IDENTIFIER>>[{'type': 'input_image',")
     assert str(pil_image).endswith("<<CUSTOM-TYPE-END-IDENTIFIER>>")
     assert "base64" in str(pil_image)
+
+def test_image_as_output_field(sample_dspy_image_download):
+    """Test dspy.Image as an output field."""
+
+    class GenImageSignature(dspy.Signature):
+        description: str = dspy.InputField()
+        image: dspy.Image = dspy.OutputField(desc="Generated image")
+
+    img_b64 = sample_dspy_image_download.url.split(",")[-1]
+    expected_output = {"image": {"result": img_b64}}
+
+    predictor, lm = setup_predictor(GenImageSignature, expected_output)
+
+    result = predictor(description="Generate a great dane image")
+
+    assert isinstance(result.image, dspy.Image)
+    assert result.image.url.startswith("data:image/")
+    assert img_b64 in result.image.url