langchain-core 0.3.75__py3-none-any.whl → 0.3.77__py3-none-any.whl

langchain_core/messages/utils.py

@@ -5,6 +5,7 @@ Some examples of what you can do with these functions include:
 * Convert messages to strings (serialization)
 * Convert messages from dicts to Message objects (deserialization)
 * Filter messages from a list of messages based on name, type or id etc.
+
 """
 
 from __future__ import annotations
@@ -42,12 +43,17 @@ from langchain_core.messages.system import SystemMessage, SystemMessageChunk
 from langchain_core.messages.tool import ToolCall, ToolMessage, ToolMessageChunk
 
 if TYPE_CHECKING:
-    from langchain_text_splitters import TextSplitter
-
     from langchain_core.language_models import BaseLanguageModel
     from langchain_core.prompt_values import PromptValue
     from langchain_core.runnables.base import Runnable
 
+try:
+    from langchain_text_splitters import TextSplitter
+
+    _HAS_LANGCHAIN_TEXT_SPLITTERS = True
+except ImportError:
+    _HAS_LANGCHAIN_TEXT_SPLITTERS = False
+
 logger = logging.getLogger(__name__)
 
 
@@ -86,13 +92,14 @@ AnyMessage = Annotated[
 def get_buffer_string(
     messages: Sequence[BaseMessage], human_prefix: str = "Human", ai_prefix: str = "AI"
 ) -> str:
-    r"""Convert a sequence of Messages to strings and concatenate them into one string.
+    r"""Convert a sequence of messages to strings and concatenate them into one string.
 
     Args:
         messages: Messages to be converted to strings.
-        human_prefix: The prefix to prepend to contents of HumanMessages.
-            Default is "Human".
-        ai_prefix: THe prefix to prepend to contents of AIMessages. Default is "AI".
+        human_prefix: The prefix to prepend to contents of ``HumanMessage``s.
+            Default is ``'Human'``.
+        ai_prefix: The prefix to prepend to contents of ``AIMessage``. Default is
+            ``'AI'``.
 
     Returns:
         A single string concatenation of all input messages.
@@ -171,19 +178,20 @@ def _message_from_dict(message: dict) -> BaseMessage:
 
 
 def messages_from_dict(messages: Sequence[dict]) -> list[BaseMessage]:
-    """Convert a sequence of messages from dicts to Message objects.
+    """Convert a sequence of messages from dicts to ``Message`` objects.
 
     Args:
         messages: Sequence of messages (as dicts) to convert.
 
     Returns:
         list of messages (BaseMessages).
+
     """
     return [_message_from_dict(m) for m in messages]
 
 
-def message_chunk_to_message(chunk: BaseMessageChunk) -> BaseMessage:
-    """Convert a message chunk to a message.
+def message_chunk_to_message(chunk: BaseMessage) -> BaseMessage:
+    """Convert a message chunk to a ``Message``.
 
     Args:
         chunk: Message chunk to convert.
@@ -216,10 +224,10 @@ def _create_message_from_message_type(
     id: Optional[str] = None,
     **additional_kwargs: Any,
 ) -> BaseMessage:
-    """Create a message from a message type and content string.
+    """Create a message from a ``Message`` type and content string.
 
     Args:
-        message_type: (str) the type of the message (e.g., "human", "ai", etc.).
+        message_type: (str) the type of the message (e.g., ``'human'``, ``'ai'``, etc.).
         content: (str) the content string.
         name: (str) the name of the message. Default is None.
         tool_call_id: (str) the tool call id. Default is None.
@@ -231,8 +239,9 @@ def _create_message_from_message_type(
         a message of the appropriate type.
 
     Raises:
-        ValueError: if the message type is not one of "human", "user", "ai",
-            "assistant", "function", "tool", "system", or "developer".
+        ValueError: if the message type is not one of ``'human'``, ``'user'``, ``'ai'``,
+            ``'assistant'``, ``'function'``, ``'tool'``, ``'system'``, or
+            ``'developer'``.
     """
     kwargs: dict[str, Any] = {}
     if name is not None:
@@ -281,6 +290,9 @@ def _create_message_from_message_type(
         message = FunctionMessage(content=content, **kwargs)
     elif message_type == "tool":
         artifact = kwargs.get("additional_kwargs", {}).pop("artifact", None)
+        status = kwargs.get("additional_kwargs", {}).pop("status", None)
+        if status is not None:
+            kwargs["status"] = status
         message = ToolMessage(content=content, artifact=artifact, **kwargs)
     elif message_type == "remove":
         message = RemoveMessage(**kwargs)
@@ -295,15 +307,15 @@ def _create_message_from_message_type(
 
 
 def _convert_to_message(message: MessageLikeRepresentation) -> BaseMessage:
-    """Instantiate a message from a variety of message formats.
+    """Instantiate a ``Message`` from a variety of message formats.
 
     The message format can be one of the following:
 
-    - BaseMessagePromptTemplate
-    - BaseMessage
-    - 2-tuple of (role string, template); e.g., ("human", "{user_input}")
+    - ``BaseMessagePromptTemplate``
+    - ``BaseMessage``
+    - 2-tuple of (role string, template); e.g., (``'human'``, ``'{user_input}'``)
     - dict: a message dict with role and content keys
-    - string: shorthand for ("human", template); e.g., "{user_input}"
+    - string: shorthand for (``'human'``, template); e.g., ``'{user_input}'``
 
     Args:
         message: a representation of a message in one of the supported formats.
@@ -314,6 +326,7 @@ def _convert_to_message(message: MessageLikeRepresentation) -> BaseMessage:
     Raises:
         NotImplementedError: if the message type is not supported.
         ValueError: if the message dict does not contain the required keys.
+
     """
     if isinstance(message, BaseMessage):
         message_ = message
@@ -359,9 +372,10 @@ def convert_to_messages(
 
     Returns:
         list of messages (BaseMessages).
+
     """
     # Import here to avoid circular imports
-    from langchain_core.prompt_values import PromptValue
+    from langchain_core.prompt_values import PromptValue  # noqa: PLC0415
 
     if isinstance(messages, PromptValue):
         return messages.to_messages()
@@ -386,7 +400,8 @@ def _runnable_support(func: Callable) -> Callable:
         list[BaseMessage],
         Runnable[Sequence[MessageLikeRepresentation], list[BaseMessage]],
     ]:
-        from langchain_core.runnables.base import RunnableLambda
+        # Import locally to prevent circular import.
+        from langchain_core.runnables.base import RunnableLambda  # noqa: PLC0415
 
         if messages is not None:
             return func(messages, **kwargs)
@@ -408,31 +423,36 @@ def filter_messages(
     exclude_ids: Optional[Sequence[str]] = None,
     exclude_tool_calls: Optional[Sequence[str] | bool] = None,
 ) -> list[BaseMessage]:
-    """Filter messages based on name, type or id.
+    """Filter messages based on ``name``, ``type`` or ``id``.
 
     Args:
         messages: Sequence Message-like objects to filter.
         include_names: Message names to include. Default is None.
         exclude_names: Messages names to exclude. Default is None.
-        include_types: Message types to include. Can be specified as string names (e.g.
-            "system", "human", "ai", ...) or as BaseMessage classes (e.g.
-            SystemMessage, HumanMessage, AIMessage, ...). Default is None.
-        exclude_types: Message types to exclude. Can be specified as string names (e.g.
-            "system", "human", "ai", ...) or as BaseMessage classes (e.g.
-            SystemMessage, HumanMessage, AIMessage, ...). Default is None.
+        include_types: Message types to include. Can be specified as string names
+            (e.g. ``'system'``, ``'human'``, ``'ai'``, ...) or as ``BaseMessage``
+            classes (e.g. ``SystemMessage``, ``HumanMessage``, ``AIMessage``, ...).
+            Default is None.
+        exclude_types: Message types to exclude. Can be specified as string names
+            (e.g. ``'system'``, ``'human'``, ``'ai'``, ...) or as ``BaseMessage``
+            classes (e.g. ``SystemMessage``, ``HumanMessage``, ``AIMessage``, ...).
+            Default is None.
         include_ids: Message IDs to include. Default is None.
         exclude_ids: Message IDs to exclude. Default is None.
         exclude_tool_calls: Tool call IDs to exclude. Default is None.
             Can be one of the following:
-            - `True`: all AIMessages with tool calls and all ToolMessages will be excluded.
+            - ``True``: all ``AIMessage``s with tool calls and all
+              ``ToolMessage``s will be excluded.
             - a sequence of tool call IDs to exclude:
-              - ToolMessages with the corresponding tool call ID will be excluded.
-              - The `tool_calls` in the AIMessage will be updated to exclude matching tool calls.
-                If all tool_calls are filtered from an AIMessage, the whole message is excluded.
+              - ``ToolMessage``s with the corresponding tool call ID will be
+                excluded.
+              - The ``tool_calls`` in the AIMessage will be updated to exclude
+                matching tool calls. If all ``tool_calls`` are filtered from an
+                AIMessage, the whole message is excluded.
 
     Returns:
-        A list of Messages that meets at least one of the incl_* conditions and none
-        of the excl_* conditions. If not incl_* conditions are specified then
+        A list of Messages that meets at least one of the ``incl_*`` conditions and none
+        of the ``excl_*`` conditions. If not ``incl_*`` conditions are specified then
         anything that is not explicitly excluded will be included.
 
     Raises:
@@ -441,14 +461,25 @@ def filter_messages(
     Example:
         .. code-block:: python
 
-            from langchain_core.messages import filter_messages, AIMessage, HumanMessage, SystemMessage
+            from langchain_core.messages import (
+                filter_messages,
+                AIMessage,
+                HumanMessage,
+                SystemMessage,
+            )
 
             messages = [
                 SystemMessage("you're a good assistant."),
                 HumanMessage("what's your name", id="foo", name="example_user"),
                 AIMessage("steve-o", id="bar", name="example_assistant"),
-                HumanMessage("what's your favorite color", id="baz",),
-                AIMessage("silicon blue", id="blah",),
+                HumanMessage(
+                    "what's your favorite color",
+                    id="baz",
+                ),
+                AIMessage(
+                    "silicon blue",
+                    id="blah",
+                ),
             ]
 
             filter_messages(
@@ -465,7 +496,7 @@ def filter_messages(
                 HumanMessage("what's your name", id="foo", name="example_user"),
             ]
 
-    """  # noqa: E501
+    """
     messages = convert_to_messages(messages)
     filtered: list[BaseMessage] = []
     for msg in messages:
@@ -533,23 +564,26 @@ def merge_message_runs(
 ) -> list[BaseMessage]:
     r"""Merge consecutive Messages of the same type.
 
-    **NOTE**: ToolMessages are not merged, as each has a distinct tool call id that
-    can't be merged.
+    .. note::
+        ToolMessages are not merged, as each has a distinct tool call id that can't be
+        merged.
 
     Args:
         messages: Sequence Message-like objects to merge.
         chunk_separator: Specify the string to be inserted between message chunks.
-        Default is "\n".
+        Default is ``'\n'``.
 
     Returns:
         list of BaseMessages with consecutive runs of message types merged into single
         messages. By default, if two messages being merged both have string contents,
-        the merged content is a concatenation of the two strings with a new-line separator.
+        the merged content is a concatenation of the two strings with a new-line
+        separator.
         The separator inserted between message chunks can be controlled by specifying
-        any string with ``chunk_separator``. If at least one of the messages has a list of
-        content blocks, the merged content is a list of content blocks.
+        any string with ``chunk_separator``. If at least one of the messages has a list
+        of content blocks, the merged content is a list of content blocks.
 
     Example:
+
         .. code-block:: python
 
             from langchain_core.messages import (
@@ -562,16 +596,33 @@ def merge_message_runs(
 
             messages = [
                 SystemMessage("you're a good assistant."),
-                HumanMessage("what's your favorite color", id="foo",),
-                HumanMessage("wait your favorite food", id="bar",),
+                HumanMessage(
+                    "what's your favorite color",
+                    id="foo",
+                ),
+                HumanMessage(
+                    "wait your favorite food",
+                    id="bar",
+                ),
                 AIMessage(
                     "my favorite colo",
-                    tool_calls=[ToolCall(name="blah_tool", args={"x": 2}, id="123", type="tool_call")],
+                    tool_calls=[
+                        ToolCall(
+                            name="blah_tool", args={"x": 2}, id="123", type="tool_call"
+                        )
+                    ],
                     id="baz",
                 ),
                 AIMessage(
                     [{"type": "text", "text": "my favorite dish is lasagna"}],
-                    tool_calls=[ToolCall(name="blah_tool", args={"x": -10}, id="456", type="tool_call")],
+                    tool_calls=[
+                        ToolCall(
+                            name="blah_tool",
+                            args={"x": -10},
+                            id="456",
+                            type="tool_call",
+                        )
+                    ],
                     id="blur",
                 ),
             ]
@@ -582,21 +633,34 @@ def merge_message_runs(
 
             [
                 SystemMessage("you're a good assistant."),
-                HumanMessage("what's your favorite color\\nwait your favorite food", id="foo",),
+                HumanMessage(
+                    "what's your favorite color\\n"
+                    "wait your favorite food", id="foo",
+                ),
                 AIMessage(
                     [
                         "my favorite colo",
                         {"type": "text", "text": "my favorite dish is lasagna"}
                     ],
                     tool_calls=[
-                        ToolCall({"name": "blah_tool", "args": {"x": 2}, "id": "123", "type": "tool_call"}),
-                        ToolCall({"name": "blah_tool", "args": {"x": -10}, "id": "456", "type": "tool_call"})
+                        ToolCall({
+                            "name": "blah_tool",
+                            "args": {"x": 2},
+                            "id": "123",
+                            "type": "tool_call"
+                        }),
+                        ToolCall({
+                            "name": "blah_tool",
+                            "args": {"x": -10},
+                            "id": "456",
+                            "type": "tool_call"
+                        })
                     ]
                     id="baz"
                 ),
             ]
 
-    """  # noqa: E501
+    """
     if not messages:
         return []
     messages = convert_to_messages(messages)
@@ -648,22 +712,22 @@ def trim_messages(
 ) -> list[BaseMessage]:
     r"""Trim messages to be below a token count.
 
-    trim_messages can be used to reduce the size of a chat history to a specified token
-    count or specified message count.
+    ``trim_messages`` can be used to reduce the size of a chat history to a specified
+    token count or specified message count.
 
     In either case, if passing the trimmed chat history back into a chat model
     directly, the resulting chat history should usually satisfy the following
     properties:
 
     1. The resulting chat history should be valid. Most chat models expect that chat
-       history starts with either (1) a ``HumanMessage`` or (2) a ``SystemMessage`` followed
-       by a ``HumanMessage``. To achieve this, set ``start_on="human"``.
+       history starts with either (1) a ``HumanMessage`` or (2) a ``SystemMessage``
+       followed by a ``HumanMessage``. To achieve this, set ``start_on='human'``.
        In addition, generally a ``ToolMessage`` can only appear after an ``AIMessage``
        that involved a tool call.
        Please see the following link for more information about messages:
        https://python.langchain.com/docs/concepts/#messages
     2. It includes recent messages and drops old messages in the chat history.
-       To achieve this set the ``strategy="last"``.
+       To achieve this set the ``strategy='last'``.
     3. Usually, the new chat history should include the ``SystemMessage`` if it
        was present in the original chat history since the ``SystemMessage`` includes
        special instructions to the chat model. The ``SystemMessage`` is almost always
@@ -677,65 +741,67 @@ def trim_messages(
     Args:
         messages: Sequence of Message-like objects to trim.
         max_tokens: Max token count of trimmed messages.
-        token_counter: Function or llm for counting tokens in a BaseMessage or a list of
-            BaseMessage. If a BaseLanguageModel is passed in then
-            BaseLanguageModel.get_num_tokens_from_messages() will be used.
-            Set to `len` to count the number of **messages** in the chat history.
+        token_counter: Function or llm for counting tokens in a ``BaseMessage`` or a
+            list of ``BaseMessage``. If a ``BaseLanguageModel`` is passed in then
+            ``BaseLanguageModel.get_num_tokens_from_messages()`` will be used.
+            Set to ``len`` to count the number of **messages** in the chat history.
 
             .. note::
-                Use `count_tokens_approximately` to get fast, approximate token counts.
-                This is recommended for using `trim_messages` on the hot path, where
+                Use ``count_tokens_approximately`` to get fast, approximate token
+                counts.
+                This is recommended for using ``trim_messages`` on the hot path, where
                 exact token counting is not necessary.
 
         strategy: Strategy for trimming.
-            - "first": Keep the first <= n_count tokens of the messages.
-            - "last": Keep the last <= n_count tokens of the messages.
-            Default is "last".
+            - ``'first'``: Keep the first ``<= n_count`` tokens of the messages.
+            - ``'last'``: Keep the last ``<= n_count`` tokens of the messages.
+            Default is ``'last'``.
         allow_partial: Whether to split a message if only part of the message can be
-            included. If ``strategy="last"`` then the last partial contents of a message
-            are included. If ``strategy="first"`` then the first partial contents of a
+            included. If ``strategy='last'`` then the last partial contents of a message
+            are included. If ``strategy='first'`` then the first partial contents of a
             message are included.
             Default is False.
         end_on: The message type to end on. If specified then every message after the
-            last occurrence of this type is ignored. If ``strategy=="last"`` then this
+            last occurrence of this type is ignored. If ``strategy='last'`` then this
             is done before we attempt to get the last ``max_tokens``. If
-            ``strategy=="first"`` then this is done after we get the first
-            ``max_tokens``. Can be specified as string names (e.g. "system", "human",
-            "ai", ...) or as BaseMessage classes (e.g. SystemMessage, HumanMessage,
-            AIMessage, ...). Can be a single type or a list of types.
+            ``strategy='first'`` then this is done after we get the first
+            ``max_tokens``. Can be specified as string names (e.g. ``'system'``,
+            ``'human'``, ``'ai'``, ...) or as ``BaseMessage`` classes (e.g.
+            ``SystemMessage``, ``HumanMessage``, ``AIMessage``, ...). Can be a single
+            type or a list of types.
             Default is None.
         start_on: The message type to start on. Should only be specified if
-            ``strategy="last"``. If specified then every message before
+            ``strategy='last'``. If specified then every message before
             the first occurrence of this type is ignored. This is done after we trim
             the initial messages to the last ``max_tokens``. Does not
-            apply to a SystemMessage at index 0 if ``include_system=True``. Can be
-            specified as string names (e.g. "system", "human", "ai", ...) or as
-            BaseMessage classes (e.g. SystemMessage, HumanMessage, AIMessage, ...). Can
-            be a single type or a list of types.
+            apply to a ``SystemMessage`` at index 0 if ``include_system=True``. Can be
+            specified as string names (e.g. ``'system'``, ``'human'``, ``'ai'``, ...) or
+            as ``BaseMessage`` classes (e.g. ``SystemMessage``, ``HumanMessage``,
+            ``AIMessage``, ...). Can be a single type or a list of types.
             Default is None.
         include_system: Whether to keep the SystemMessage if there is one at index 0.
             Should only be specified if ``strategy="last"``.
             Default is False.
         text_splitter: Function or ``langchain_text_splitters.TextSplitter`` for
             splitting the string contents of a message. Only used if
-            ``allow_partial=True``. If ``strategy="last"`` then the last split tokens
-            from a partial message will be included. if ``strategy=="first"`` then the
+            ``allow_partial=True``. If ``strategy='last'`` then the last split tokens
+            from a partial message will be included. if ``strategy='first'`` then the
             first split tokens from a partial message will be included. Token splitter
             assumes that separators are kept, so that split contents can be directly
             concatenated to recreate the original text. Defaults to splitting on
             newlines.
 
     Returns:
-        list of trimmed BaseMessages.
+        list of trimmed ``BaseMessage``.
 
     Raises:
         ValueError: if two incompatible arguments are specified or an unrecognized
             ``strategy`` is specified.
 
     Example:
-        Trim chat history based on token count, keeping the SystemMessage if
-        present, and ensuring that the chat history starts with a HumanMessage (
-        or a SystemMessage followed by a HumanMessage).
+        Trim chat history based on token count, keeping the ``SystemMessage`` if
+        present, and ensuring that the chat history starts with a ``HumanMessage`` (
+        or a ``SystemMessage`` followed by a ``HumanMessage``).
 
         .. code-block:: python
 
@@ -748,14 +814,18 @@ def trim_messages(
             )
 
             messages = [
-                SystemMessage("you're a good assistant, you always respond with a joke."),
+                SystemMessage(
+                    "you're a good assistant, you always respond with a joke."
+                ),
                 HumanMessage("i wonder why it's called langchain"),
                 AIMessage(
-                    'Well, I guess they thought "WordRope" and "SentenceString" just didn\'t have the same ring to it!'
+                    'Well, I guess they thought "WordRope" and "SentenceString" just '
+                    "didn't have the same ring to it!"
                 ),
                 HumanMessage("and who is harrison chasing anyways"),
                 AIMessage(
-                    "Hmmm let me think.\n\nWhy, he's probably chasing after the last cup of coffee in the office!"
+                    "Hmmm let me think.\n\nWhy, he's probably chasing after the last "
+                    "cup of coffee in the office!"
                 ),
                 HumanMessage("what do you call a speechless parrot"),
             ]
@@ -780,13 +850,15 @@ def trim_messages(
         .. code-block:: python
 
             [
-                SystemMessage(content="you're a good assistant, you always respond with a joke."),
-                HumanMessage(content='what do you call a speechless parrot'),
+                SystemMessage(
+                    content="you're a good assistant, you always respond with a joke."
+                ),
+                HumanMessage(content="what do you call a speechless parrot"),
             ]
 
-        Trim chat history based on the message count, keeping the SystemMessage if
-        present, and ensuring that the chat history starts with a HumanMessage (
-        or a SystemMessage followed by a HumanMessage).
+        Trim chat history based on the message count, keeping the ``SystemMessage`` if
+        present, and ensuring that the chat history starts with a ``HumanMessage`` (
+        or a ``SystemMessage`` followed by a ``HumanMessage``).
 
             trim_messages(
                 messages,
@@ -811,10 +883,15 @@ def trim_messages(
         .. code-block:: python
 
             [
-                SystemMessage(content="you're a good assistant, you always respond with a joke."),
-                HumanMessage(content='and who is harrison chasing anyways'),
-                AIMessage(content="Hmmm let me think.\n\nWhy, he's probably chasing after the last cup of coffee in the office!"),
-                HumanMessage(content='what do you call a speechless parrot'),
+                SystemMessage(
+                    content="you're a good assistant, you always respond with a joke."
+                ),
+                HumanMessage(content="and who is harrison chasing anyways"),
+                AIMessage(
+                    content="Hmmm let me think.\n\nWhy, he's probably chasing after "
+                    "the last cup of coffee in the office!"
+                ),
+                HumanMessage(content="what do you call a speechless parrot"),
             ]
 
 
@@ -825,7 +902,9 @@ def trim_messages(
 
             messages = [
                 SystemMessage("This is a 4 token text. The full message is 10 tokens."),
-                HumanMessage("This is a 4 token text. The full message is 10 tokens.", id="first"),
+                HumanMessage(
+                    "This is a 4 token text. The full message is 10 tokens.", id="first"
+                ),
                 AIMessage(
                     [
                         {"type": "text", "text": "This is the FIRST 4 token block."},
@@ -833,10 +912,16 @@ def trim_messages(
                     ],
                     id="second",
                 ),
-                HumanMessage("This is a 4 token text. The full message is 10 tokens.", id="third"),
-                AIMessage("This is a 4 token text. The full message is 10 tokens.", id="fourth"),
+                HumanMessage(
+                    "This is a 4 token text. The full message is 10 tokens.", id="third"
+                ),
+                AIMessage(
+                    "This is a 4 token text. The full message is 10 tokens.",
+                    id="fourth",
+                ),
             ]
 
+
             def dummy_token_counter(messages: list[BaseMessage]) -> int:
                 # treat each message like it adds 3 default tokens at the beginning
                 # of the message and at the end of the message. 3 + 4 + 3 = 10 tokens
@@ -849,9 +934,17 @@ def trim_messages(
                 count = 0
                 for msg in messages:
                     if isinstance(msg.content, str):
-                        count += default_msg_prefix_len + default_content_len + default_msg_suffix_len
+                        count += (
+                            default_msg_prefix_len
+                            + default_content_len
+                            + default_msg_suffix_len
+                        )
                     if isinstance(msg.content, list):
-                        count += default_msg_prefix_len + len(msg.content) *  default_content_len + default_msg_suffix_len
+                        count += (
+                            default_msg_prefix_len
+                            + len(msg.content) * default_content_len
+                            + default_msg_suffix_len
+                        )
                 return count
 
         First 30 tokens, allowing partial messages:
@@ -868,12 +961,20 @@ def trim_messages(
             .. code-block:: python
 
                 [
-                    SystemMessage("This is a 4 token text. The full message is 10 tokens."),
-                    HumanMessage("This is a 4 token text. The full message is 10 tokens.", id="first"),
-                    AIMessage( [{"type": "text", "text": "This is the FIRST 4 token block."}], id="second"),
+                    SystemMessage(
+                        "This is a 4 token text. The full message is 10 tokens."
+                    ),
+                    HumanMessage(
+                        "This is a 4 token text. The full message is 10 tokens.",
+                        id="first",
+                    ),
+                    AIMessage(
+                        [{"type": "text", "text": "This is the FIRST 4 token block."}],
+                        id="second",
+                    ),
                 ]
 
-    """  # noqa: E501
+    """
     # Validate arguments
     if start_on and strategy == "first":
         msg = "start_on parameter is only valid with strategy='last'"
@@ -904,17 +1005,12 @@ def trim_messages(
         )
         raise ValueError(msg)
 
-    try:
-        from langchain_text_splitters import TextSplitter
-    except ImportError:
-        text_splitter_fn: Optional[Callable] = cast("Optional[Callable]", text_splitter)
+    if _HAS_LANGCHAIN_TEXT_SPLITTERS and isinstance(text_splitter, TextSplitter):
+        text_splitter_fn = text_splitter.split_text
+    elif text_splitter:
+        text_splitter_fn = cast("Callable", text_splitter)
     else:
-        if isinstance(text_splitter, TextSplitter):
-            text_splitter_fn = text_splitter.split_text
-        else:
-            text_splitter_fn = text_splitter
-
-    text_splitter_fn = text_splitter_fn or _default_text_splitter
+        text_splitter_fn = _default_text_splitter
 
     if strategy == "first":
         return _first_max_tokens(
@@ -951,26 +1047,30 @@ def convert_to_openai_messages(
         messages: Message-like object or iterable of objects whose contents are
             in OpenAI, Anthropic, Bedrock Converse, or VertexAI formats.
         text_format: How to format string or text block contents:
-
-                - "string":
+                - ``'string'``:
                     If a message has a string content, this is left as a string. If
-                    a message has content blocks that are all of type 'text', these are
-                    joined with a newline to make a single string. If a message has
-                    content blocks and at least one isn't of type 'text', then
+                    a message has content blocks that are all of type ``'text'``, these
+                    are joined with a newline to make a single string. If a message has
+                    content blocks and at least one isn't of type ``'text'``, then
                     all blocks are left as dicts.
-                - "block":
+                - ``'block'``:
                     If a message has a string content, this is turned into a list
-                    with a single content block of type 'text'. If a message has content
-                    blocks these are left as is.
+                    with a single content block of type ``'text'``. If a message has
+                    content blocks these are left as is.
+
+    Raises:
+        ValueError: if an unrecognized ``text_format`` is specified, or if a message
+            content block is missing expected keys.
 
     Returns:
         The return type depends on the input type:
-            - dict:
-                If a single message-like object is passed in, a single OpenAI message
-                dict is returned.
-            - list[dict]:
-                If a sequence of message-like objects are passed in, a list of OpenAI
-                message dicts is returned.
+
+        - dict:
+          If a single message-like object is passed in, a single OpenAI message
+          dict is returned.
+        - list[dict]:
+          If a sequence of message-like objects are passed in, a list of OpenAI
+          message dicts is returned.
 
     Example:
 
@@ -985,8 +1085,27 @@ def convert_to_openai_messages(
 
             messages = [
                 SystemMessage([{"type": "text", "text": "foo"}]),
-                {"role": "user", "content": [{"type": "text", "text": "whats in this"}, {"type": "image_url", "image_url": {"url": "data:image/png;base64,'/9j/4AAQSk'"}}]},
-                AIMessage("", tool_calls=[{"name": "analyze", "args": {"baz": "buz"}, "id": "1", "type": "tool_call"}]),
+                {
+                    "role": "user",
+                    "content": [
+                        {"type": "text", "text": "whats in this"},
+                        {
+                            "type": "image_url",
+                            "image_url": {"url": "data:image/png;base64,'/9j/4AAQSk'"},
+                        },
+                    ],
+                },
+                AIMessage(
+                    "",
+                    tool_calls=[
+                        {
+                            "name": "analyze",
+                            "args": {"baz": "buz"},
+                            "id": "1",
+                            "type": "tool_call",
+                        }
+                    ],
+                ),
                 ToolMessage("foobar", tool_call_id="1", name="bar"),
                 {"role": "assistant", "content": "thats nice"},
             ]
@@ -1266,7 +1385,7 @@ def convert_to_openai_messages(
                             },
                         }
                     )
-                elif block.get("type") == "thinking":
+                elif block.get("type") in ["thinking", "reasoning"]:
                     content.append(block)
                 else:
                     err = (