langchain-core 1.0.1__py3-none-any.whl → 1.0.2__py3-none-any.whl

langchain_core/indexing/api.py

@@ -304,42 +304,42 @@ def index(
     !!! warning
 
         * In full mode, the loader should be returning
-          the entire dataset, and not just a subset of the dataset.
-          Otherwise, the auto_cleanup will remove documents that it is not
-          supposed to.
+            the entire dataset, and not just a subset of the dataset.
+            Otherwise, the auto_cleanup will remove documents that it is not
+            supposed to.
         * In incremental mode, if documents associated with a particular
-          source id appear across different batches, the indexing API
-          will do some redundant work. This will still result in the
-          correct end state of the index, but will unfortunately not be
-          100% efficient. For example, if a given document is split into 15
-          chunks, and we index them using a batch size of 5, we'll have 3 batches
-          all with the same source id. In general, to avoid doing too much
-          redundant work select as big a batch size as possible.
+            source id appear across different batches, the indexing API
+            will do some redundant work. This will still result in the
+            correct end state of the index, but will unfortunately not be
+            100% efficient. For example, if a given document is split into 15
+            chunks, and we index them using a batch size of 5, we'll have 3 batches
+            all with the same source id. In general, to avoid doing too much
+            redundant work select as big a batch size as possible.
         * The `scoped_full` mode is suitable if determining an appropriate batch size
-          is challenging or if your data loader cannot return the entire dataset at
-          once. This mode keeps track of source IDs in memory, which should be fine
-          for most use cases. If your dataset is large (10M+ docs), you will likely
-          need to parallelize the indexing process regardless.
+            is challenging or if your data loader cannot return the entire dataset at
+            once. This mode keeps track of source IDs in memory, which should be fine
+            for most use cases. If your dataset is large (10M+ docs), you will likely
+            need to parallelize the indexing process regardless.
 
     Args:
         docs_source: Data loader or iterable of documents to index.
         record_manager: Timestamped set to keep track of which documents were
             updated.
-        vector_store: VectorStore or DocumentIndex to index the documents into.
+        vector_store: `VectorStore` or DocumentIndex to index the documents into.
         batch_size: Batch size to use when indexing.
         cleanup: How to handle clean up of documents.
 
             - incremental: Cleans up all documents that haven't been updated AND
-              that are associated with source ids that were seen during indexing.
-              Clean up is done continuously during indexing helping to minimize the
-              probability of users seeing duplicated content.
+                that are associated with source IDs that were seen during indexing.
+                Clean up is done continuously during indexing helping to minimize the
+                probability of users seeing duplicated content.
             - full: Delete all documents that have not been returned by the loader
-              during this run of indexing.
-              Clean up runs after all documents have been indexed.
-              This means that users may see duplicated content during indexing.
+                during this run of indexing.
+                Clean up runs after all documents have been indexed.
+                This means that users may see duplicated content during indexing.
             - scoped_full: Similar to Full, but only deletes all documents
-              that haven't been updated AND that are associated with
-              source ids that were seen during indexing.
+                that haven't been updated AND that are associated with
+                source IDs that were seen during indexing.
             - None: Do not delete any documents.
         source_id_key: Optional key that helps identify the original source
             of the document.
@@ -363,7 +363,7 @@ def index(
             When changing the key encoder, you must change the
             index as well to avoid duplicated documents in the cache.
         upsert_kwargs: Additional keyword arguments to pass to the add_documents
-            method of the VectorStore or the upsert method of the DocumentIndex.
+            method of the `VectorStore` or the upsert method of the DocumentIndex.
             For example, you can use this to specify a custom vector_field:
             upsert_kwargs={"vector_field": "embedding"}
             !!! version-added "Added in version 0.3.10"
@@ -375,10 +375,10 @@ def index(
     Raises:
         ValueError: If cleanup mode is not one of 'incremental', 'full' or None
         ValueError: If cleanup mode is incremental and source_id_key is None.
-        ValueError: If vectorstore does not have
+        ValueError: If `VectorStore` does not have
             "delete" and "add_documents" required methods.
         ValueError: If source_id_key is not None, but is not a string or callable.
-        TypeError: If `vectorstore` is not a VectorStore or a DocumentIndex.
+        TypeError: If `vectorstore` is not a `VectorStore` or a DocumentIndex.
         AssertionError: If `source_id` is None when cleanup mode is incremental.
             (should be unreachable code).
     """
@@ -415,7 +415,7 @@ def index(
                 raise ValueError(msg)
 
         if type(destination).delete == VectorStore.delete:
-            # Checking if the vectorstore has overridden the default delete method
+            # Checking if the VectorStore has overridden the default delete method
             # implementation which just raises a NotImplementedError
             msg = "Vectorstore has not implemented the delete method"
             raise ValueError(msg)
@@ -466,11 +466,11 @@ def index(
         ]
 
         if cleanup in {"incremental", "scoped_full"}:
-            # source ids are required.
+            # Source IDs are required.
             for source_id, hashed_doc in zip(source_ids, hashed_docs, strict=False):
                 if source_id is None:
                     msg = (
-                        f"Source ids are required when cleanup mode is "
+                        f"Source IDs are required when cleanup mode is "
                         f"incremental or scoped_full. "
                         f"Document that starts with "
                         f"content: {hashed_doc.page_content[:100]} "
@@ -479,7 +479,7 @@ def index(
                     raise ValueError(msg)
                 if cleanup == "scoped_full":
                     scoped_full_cleanup_source_ids.add(source_id)
-            # source ids cannot be None after for loop above.
+            # Source IDs cannot be None after for loop above.
             source_ids = cast("Sequence[str]", source_ids)
 
         exists_batch = record_manager.exists(
@@ -538,7 +538,7 @@ def index(
         # If source IDs are provided, we can do the deletion incrementally!
         if cleanup == "incremental":
             # Get the uids of the documents that were not returned by the loader.
-            # mypy isn't good enough to determine that source ids cannot be None
+            # mypy isn't good enough to determine that source IDs cannot be None
             # here due to a check that's happening above, so we check again.
             for source_id in source_ids:
                 if source_id is None:
@@ -642,42 +642,42 @@ async def aindex(
     !!! warning
 
         * In full mode, the loader should be returning
-          the entire dataset, and not just a subset of the dataset.
-          Otherwise, the auto_cleanup will remove documents that it is not
-          supposed to.
+            the entire dataset, and not just a subset of the dataset.
+            Otherwise, the auto_cleanup will remove documents that it is not
+            supposed to.
         * In incremental mode, if documents associated with a particular
-          source id appear across different batches, the indexing API
-          will do some redundant work. This will still result in the
-          correct end state of the index, but will unfortunately not be
-          100% efficient. For example, if a given document is split into 15
-          chunks, and we index them using a batch size of 5, we'll have 3 batches
-          all with the same source id. In general, to avoid doing too much
-          redundant work select as big a batch size as possible.
+            source id appear across different batches, the indexing API
+            will do some redundant work. This will still result in the
+            correct end state of the index, but will unfortunately not be
+            100% efficient. For example, if a given document is split into 15
+            chunks, and we index them using a batch size of 5, we'll have 3 batches
+            all with the same source id. In general, to avoid doing too much
+            redundant work select as big a batch size as possible.
         * The `scoped_full` mode is suitable if determining an appropriate batch size
-          is challenging or if your data loader cannot return the entire dataset at
-          once. This mode keeps track of source IDs in memory, which should be fine
-          for most use cases. If your dataset is large (10M+ docs), you will likely
-          need to parallelize the indexing process regardless.
+            is challenging or if your data loader cannot return the entire dataset at
+            once. This mode keeps track of source IDs in memory, which should be fine
+            for most use cases. If your dataset is large (10M+ docs), you will likely
+            need to parallelize the indexing process regardless.
 
     Args:
         docs_source: Data loader or iterable of documents to index.
         record_manager: Timestamped set to keep track of which documents were
             updated.
-        vector_store: VectorStore or DocumentIndex to index the documents into.
+        vector_store: `VectorStore` or DocumentIndex to index the documents into.
         batch_size: Batch size to use when indexing.
         cleanup: How to handle clean up of documents.
 
             - incremental: Cleans up all documents that haven't been updated AND
-              that are associated with source ids that were seen during indexing.
-              Clean up is done continuously during indexing helping to minimize the
-              probability of users seeing duplicated content.
+                that are associated with source IDs that were seen during indexing.
+                Clean up is done continuously during indexing helping to minimize the
+                probability of users seeing duplicated content.
             - full: Delete all documents that have not been returned by the loader
-              during this run of indexing.
-              Clean up runs after all documents have been indexed.
-              This means that users may see duplicated content during indexing.
+                during this run of indexing.
+                Clean up runs after all documents have been indexed.
+                This means that users may see duplicated content during indexing.
             - scoped_full: Similar to Full, but only deletes all documents
-              that haven't been updated AND that are associated with
-              source ids that were seen during indexing.
+                that haven't been updated AND that are associated with
+                source IDs that were seen during indexing.
             - None: Do not delete any documents.
         source_id_key: Optional key that helps identify the original source
             of the document.
@@ -701,7 +701,7 @@ async def aindex(
             When changing the key encoder, you must change the
             index as well to avoid duplicated documents in the cache.
         upsert_kwargs: Additional keyword arguments to pass to the add_documents
-            method of the VectorStore or the upsert method of the DocumentIndex.
+            method of the `VectorStore` or the upsert method of the DocumentIndex.
             For example, you can use this to specify a custom vector_field:
             upsert_kwargs={"vector_field": "embedding"}
             !!! version-added "Added in version 0.3.10"
@@ -713,10 +713,10 @@ async def aindex(
     Raises:
         ValueError: If cleanup mode is not one of 'incremental', 'full' or None
         ValueError: If cleanup mode is incremental and source_id_key is None.
-        ValueError: If vectorstore does not have
+        ValueError: If `VectorStore` does not have
             "adelete" and "aadd_documents" required methods.
         ValueError: If source_id_key is not None, but is not a string or callable.
-        TypeError: If `vector_store` is not a VectorStore or DocumentIndex.
+        TypeError: If `vector_store` is not a `VectorStore` or DocumentIndex.
         AssertionError: If `source_id_key` is None when cleanup mode is
             incremental or `scoped_full` (should be unreachable).
     """
@@ -757,7 +757,7 @@ async def aindex(
             type(destination).adelete == VectorStore.adelete
             and type(destination).delete == VectorStore.delete
         ):
-            # Checking if the vectorstore has overridden the default adelete or delete
+            # Checking if the VectorStore has overridden the default adelete or delete
             # methods implementation which just raises a NotImplementedError
             msg = "Vectorstore has not implemented the adelete or delete method"
             raise ValueError(msg)
@@ -815,11 +815,11 @@ async def aindex(
         ]
 
         if cleanup in {"incremental", "scoped_full"}:
-            # If the cleanup mode is incremental, source ids are required.
+            # If the cleanup mode is incremental, source IDs are required.
             for source_id, hashed_doc in zip(source_ids, hashed_docs, strict=False):
                 if source_id is None:
                     msg = (
-                        f"Source ids are required when cleanup mode is "
+                        f"Source IDs are required when cleanup mode is "
                         f"incremental or scoped_full. "
                         f"Document that starts with "
                         f"content: {hashed_doc.page_content[:100]} "
@@ -828,7 +828,7 @@ async def aindex(
                     raise ValueError(msg)
                 if cleanup == "scoped_full":
                     scoped_full_cleanup_source_ids.add(source_id)
-            # source ids cannot be None after for loop above.
+            # Source IDs cannot be None after for loop above.
             source_ids = cast("Sequence[str]", source_ids)
 
         exists_batch = await record_manager.aexists(
@@ -888,7 +888,7 @@ async def aindex(
         if cleanup == "incremental":
             # Get the uids of the documents that were not returned by the loader.
 
-            # mypy isn't good enough to determine that source ids cannot be None
+            # mypy isn't good enough to determine that source IDs cannot be None
             # here due to a check that's happening above, so we check again.
             for source_id in source_ids:
                 if source_id is None:

langchain_core/indexing/base.py

@@ -25,7 +25,7 @@ class RecordManager(ABC):
     The record manager abstraction is used by the langchain indexing API.
 
     The record manager keeps track of which documents have been
-    written into a vectorstore and when they were written.
+    written into a `VectorStore` and when they were written.
 
     The indexing API computes hashes for each document and stores the hash
     together with the write time and the source id in the record manager.
@@ -37,7 +37,7 @@ class RecordManager(ABC):
     already been indexed, and to only index new documents.
 
     The main benefit of this abstraction is that it works across many vectorstores.
-    To be supported, a vectorstore needs to only support the ability to add and
+    To be supported, a `VectorStore` needs to only support the ability to add and
     delete documents by ID. Using the record manager, the indexing API will
     be able to delete outdated documents and avoid redundant indexing of documents
     that have already been indexed.
@@ -45,13 +45,13 @@ class RecordManager(ABC):
     The main constraints of this abstraction are:
 
     1. It relies on the time-stamps to determine which documents have been
-       indexed and which have not. This means that the time-stamps must be
-       monotonically increasing. The timestamp should be the timestamp
-       as measured by the server to minimize issues.
+        indexed and which have not. This means that the time-stamps must be
+        monotonically increasing. The timestamp should be the timestamp
+        as measured by the server to minimize issues.
     2. The record manager is currently implemented separately from the
-       vectorstore, which means that the overall system becomes distributed
-       and may create issues with consistency. For example, writing to
-       record manager succeeds, but corresponding writing to vectorstore fails.
+        vectorstore, which means that the overall system becomes distributed
+        and may create issues with consistency. For example, writing to
+        record manager succeeds, but corresponding writing to `VectorStore` fails.
     """
 
     def __init__(
@@ -460,7 +460,7 @@ class UpsertResponse(TypedDict):
 class DeleteResponse(TypedDict, total=False):
     """A generic response for delete operation.
 
-    The fields in this response are optional and whether the vectorstore
+    The fields in this response are optional and whether the `VectorStore`
     returns them or not is up to the implementation.
     """
 
@@ -518,7 +518,7 @@ class DocumentIndex(BaseRetriever):
         if it is provided. If the ID is not provided, the upsert method is free
         to generate an ID for the content.
 
-        When an ID is specified and the content already exists in the vectorstore,
+        When an ID is specified and the content already exists in the `VectorStore`,
         the upsert method should update the content with the new data. If the content
         does not exist, the upsert method should add the item to the `VectorStore`.
 
@@ -528,20 +528,20 @@ class DocumentIndex(BaseRetriever):
 
         Returns:
             A response object that contains the list of IDs that were
-            successfully added or updated in the vectorstore and the list of IDs that
+            successfully added or updated in the `VectorStore` and the list of IDs that
             failed to be added or updated.
         """
 
     async def aupsert(
         self, items: Sequence[Document], /, **kwargs: Any
     ) -> UpsertResponse:
-        """Add or update documents in the vectorstore. Async version of upsert.
+        """Add or update documents in the `VectorStore`. Async version of `upsert`.
 
         The upsert functionality should utilize the ID field of the item
         if it is provided. If the ID is not provided, the upsert method is free
         to generate an ID for the item.
 
-        When an ID is specified and the item already exists in the vectorstore,
+        When an ID is specified and the item already exists in the `VectorStore`,
         the upsert method should update the item with the new data. If the item
         does not exist, the upsert method should add the item to the `VectorStore`.
 
@@ -551,7 +551,7 @@ class DocumentIndex(BaseRetriever):
 
         Returns:
             A response object that contains the list of IDs that were
-            successfully added or updated in the vectorstore and the list of IDs that
+            successfully added or updated in the `VectorStore` and the list of IDs that
             failed to be added or updated.
         """
         return await run_in_executor(
@@ -568,7 +568,7 @@ class DocumentIndex(BaseRetriever):
         Calling delete without any input parameters should raise a ValueError!
 
         Args:
-            ids: List of ids to delete.
+            ids: List of IDs to delete.
             **kwargs: Additional keyword arguments. This is up to the implementation.
                 For example, can include an option to delete the entire index,
                 or else issue a non-blocking delete etc.
@@ -586,7 +586,7 @@ class DocumentIndex(BaseRetriever):
         Calling adelete without any input parameters should raise a ValueError!
 
         Args:
-            ids: List of ids to delete.
+            ids: List of IDs to delete.
             **kwargs: Additional keyword arguments. This is up to the implementation.
                 For example, can include an option to delete the entire index.
 

langchain_core/indexing/in_memory.py

@@ -62,10 +62,10 @@ class InMemoryDocumentIndex(DocumentIndex):
         """Delete by IDs.
 
         Args:
-            ids: List of ids to delete.
+            ids: List of IDs to delete.
 
         Raises:
-            ValueError: If ids is None.
+            ValueError: If IDs is None.
 
         Returns:
             A response object that contains the list of IDs that were successfully

langchain_core/language_models/__init__.py

@@ -6,12 +6,13 @@ LangChain has two main classes to work with language models: chat models and
 **Chat models**
 
 Language models that use a sequence of messages as inputs and return chat messages
-as outputs (as opposed to using plain text). Chat models support the assignment of
-distinct roles to conversation messages, helping to distinguish messages from the AI,
-users, and instructions such as system messages.
+as outputs (as opposed to using plain text).
 
-The key abstraction for chat models is `BaseChatModel`. Implementations
-should inherit from this class.
+Chat models support the assignment of distinct roles to conversation messages, helping
+to distinguish messages from the AI, users, and instructions such as system messages.
+
+The key abstraction for chat models is `BaseChatModel`. Implementations should inherit
+from this class.
 
 See existing [chat model integrations](https://docs.langchain.com/oss/python/integrations/chat).
 

langchain_core/language_models/base.py

@@ -262,13 +262,13 @@ class BaseLanguageModel(
         return self.lc_attributes
 
     def get_token_ids(self, text: str) -> list[int]:
-        """Return the ordered ids of the tokens in a text.
+        """Return the ordered IDs of the tokens in a text.
 
         Args:
             text: The string input to tokenize.
 
         Returns:
-            A list of ids corresponding to the tokens in the text, in order they occur
+            A list of IDs corresponding to the tokens in the text, in order they occur
                 in the text.
         """
         if self.custom_get_token_ids is not None:

langchain_core/language_models/fake_chat_models.py

@@ -1,4 +1,4 @@
-"""Fake chat model for testing purposes."""
+"""Fake chat models for testing purposes."""
 
 import asyncio
 import re

langchain_core/language_models/llms.py

@@ -1,4 +1,7 @@
-"""Base interface for large language models to expose."""
+"""Base interface for traditional large language models (LLMs) to expose.
+
+These are traditionally older models (newer models generally are chat models).
+"""
 
 from __future__ import annotations
 
@@ -1391,11 +1394,6 @@ class LLM(BaseLLM):
         `astream` will use `_astream` if provided, otherwise it will implement
         a fallback behavior that will use `_stream` if `_stream` is implemented,
         and use `_acall` if `_stream` is not implemented.
-
-    Please see the following guide for more information on how to
-    implement a custom LLM:
-
-    https://python.langchain.com/docs/how_to/custom_llm/
     """
 
     @abstractmethod

langchain_core/load/dump.py

@@ -17,7 +17,7 @@ def default(obj: Any) -> Any:
         obj: The object to serialize to json if it is a Serializable object.
 
     Returns:
-        A json serializable object or a SerializedNotImplemented object.
+        A JSON serializable object or a SerializedNotImplemented object.
     """
     if isinstance(obj, Serializable):
         return obj.to_json()

langchain_core/load/serializable.py

@@ -97,11 +97,14 @@ class Serializable(BaseModel, ABC):
         by default. This is to prevent accidental serialization of objects that should
         not be serialized.
     - `get_lc_namespace`: Get the namespace of the LangChain object.
+
         During deserialization, this namespace is used to identify
         the correct class to instantiate.
+
         Please see the `Reviver` class in `langchain_core.load.load` for more details.
         During deserialization an additional mapping is handle classes that have moved
         or been renamed across package versions.
+
     - `lc_secrets`: A map of constructor argument names to secret ids.
     - `lc_attributes`: List of additional attribute names that should be included
         as part of the serialized representation.
@@ -194,7 +197,7 @@ class Serializable(BaseModel, ABC):
             ValueError: If the class has deprecated attributes.
 
         Returns:
-            A json serializable object or a `SerializedNotImplemented` object.
+            A JSON serializable object or a `SerializedNotImplemented` object.
         """
         if not self.is_lc_serializable():
             return self.to_json_not_implemented()

langchain_core/messages/__init__.py

@@ -9,6 +9,9 @@ if TYPE_CHECKING:
     from langchain_core.messages.ai import (
         AIMessage,
         AIMessageChunk,
+        InputTokenDetails,
+        OutputTokenDetails,
+        UsageMetadata,
     )
     from langchain_core.messages.base import (
         BaseMessage,
@@ -87,10 +90,12 @@ __all__ = (
     "HumanMessage",
     "HumanMessageChunk",
     "ImageContentBlock",
+    "InputTokenDetails",
     "InvalidToolCall",
     "MessageLikeRepresentation",
     "NonStandardAnnotation",
     "NonStandardContentBlock",
+    "OutputTokenDetails",
     "PlainTextContentBlock",
     "ReasoningContentBlock",
     "RemoveMessage",
@@ -104,6 +109,7 @@ __all__ = (
     "ToolCallChunk",
     "ToolMessage",
     "ToolMessageChunk",
+    "UsageMetadata",
     "VideoContentBlock",
     "_message_from_dict",
     "convert_to_messages",
@@ -145,6 +151,7 @@ _dynamic_imports = {
     "HumanMessageChunk": "human",
     "NonStandardAnnotation": "content",
     "NonStandardContentBlock": "content",
+    "OutputTokenDetails": "ai",
     "PlainTextContentBlock": "content",
     "ReasoningContentBlock": "content",
     "RemoveMessage": "modifier",
@@ -154,12 +161,14 @@ _dynamic_imports = {
     "SystemMessage": "system",
     "SystemMessageChunk": "system",
     "ImageContentBlock": "content",
+    "InputTokenDetails": "ai",
     "InvalidToolCall": "tool",
     "TextContentBlock": "content",
     "ToolCall": "tool",
     "ToolCallChunk": "tool",
     "ToolMessage": "tool",
     "ToolMessageChunk": "tool",
+    "UsageMetadata": "ai",
     "VideoContentBlock": "content",
     "AnyMessage": "utils",
     "MessageLikeRepresentation": "utils",

langchain_core/messages/ai.py

@@ -48,10 +48,10 @@ class InputTokenDetails(TypedDict, total=False):
         }
         ```
 
-    !!! version-added "Added in version 0.3.9"
-
     May also hold extra provider-specific keys.
 
+    !!! version-added "Added in version 0.3.9"
+
     """
 
     audio: int
@@ -83,6 +83,8 @@ class OutputTokenDetails(TypedDict, total=False):
         }
         ```
 
+    May also hold extra provider-specific keys.
+
     !!! version-added "Added in version 0.3.9"
 
     """
@@ -124,6 +126,10 @@ class UsageMetadata(TypedDict):
     !!! warning "Behavior changed in 0.3.9"
         Added `input_token_details` and `output_token_details`.
 
+    !!! note "LangSmith SDK"
+        The LangSmith SDK also has a `UsageMetadata` class. While the two share fields,
+        LangSmith's `UsageMetadata` has additional fields to capture cost information
+        used by the LangSmith platform.
     """
 
     input_tokens: int
@@ -131,7 +137,7 @@ class UsageMetadata(TypedDict):
     output_tokens: int
     """Count of output (or completion) tokens. Sum of all output token types."""
     total_tokens: int
-    """Total token count. Sum of input_tokens + output_tokens."""
+    """Total token count. Sum of `input_tokens` + `output_tokens`."""
     input_token_details: NotRequired[InputTokenDetails]
     """Breakdown of input token counts.
 
@@ -141,7 +147,6 @@ class UsageMetadata(TypedDict):
     """Breakdown of output token counts.
 
     Does *not* need to sum to full output token count. Does *not* need to have all keys.
-
     """
 
 
@@ -153,7 +158,6 @@ class AIMessage(BaseMessage):
     This message represents the output of the model and consists of both
     the raw output as returned by the model and standardized fields
     (e.g., tool calls, usage metadata) added by the LangChain framework.
-
     """
 
     tool_calls: list[ToolCall] = []
@@ -651,13 +655,13 @@ def add_ai_message_chunks(
             chunk_id = id_
             break
     else:
-        # second pass: prefer lc_run-* ids over lc_* ids
+        # second pass: prefer lc_run-* IDs over lc_* IDs
         for id_ in candidates:
             if id_ and id_.startswith(LC_ID_PREFIX):
                 chunk_id = id_
                 break
         else:
-            # third pass: take any remaining id (auto-generated lc_* ids)
+            # third pass: take any remaining ID (auto-generated lc_* IDs)
             for id_ in candidates:
                 if id_:
                     chunk_id = id_

langchain_core/messages/base.py

@@ -93,6 +93,10 @@ class BaseMessage(Serializable):
     """Base abstract message class.
 
     Messages are the inputs and outputs of a chat model.
+
+    Examples include [`HumanMessage`][langchain.messages.HumanMessage],
+    [`AIMessage`][langchain.messages.AIMessage], and
+    [`SystemMessage`][langchain.messages.SystemMessage].
     """
 
     content: str | list[str | dict]

langchain_core/messages/block_translators/google_genai.py

@@ -368,7 +368,7 @@ def _convert_to_v1_from_genai(message: AIMessage) -> list[types.ContentBlock]:
                     else:
                         # Assume it's raw base64 without data URI
                         try:
-                            # Validate base64 and decode for mime type detection
+                            # Validate base64 and decode for MIME type detection
                             decoded_bytes = base64.b64decode(url, validate=True)
 
                             image_url_b64_block = {
@@ -379,7 +379,7 @@ def _convert_to_v1_from_genai(message: AIMessage) -> list[types.ContentBlock]:
                             try:
                                 import filetype  # type: ignore[import-not-found] # noqa: PLC0415
 
-                                # Guess mime type based on file bytes
+                                # Guess MIME type based on file bytes
                                 mime_type = None
                                 kind = filetype.guess(decoded_bytes)
                                 if kind:
@@ -458,6 +458,8 @@ def _convert_to_v1_from_genai(message: AIMessage) -> list[types.ContentBlock]:
                 if outcome is not None:
                     server_tool_result_block["extras"]["outcome"] = outcome
                 converted_blocks.append(server_tool_result_block)
+            elif item_type == "text":
+                converted_blocks.append(cast("types.TextContentBlock", item))
             else:
                 # Unknown type, preserve as non-standard
                 converted_blocks.append({"type": "non_standard", "value": item})