langchain 0.3.26__py3-none-any.whl → 0.4.0.dev0__py3-none-any.whl

langchain/chat_models/base.py

@@ -3,15 +3,7 @@ from __future__ import annotations
 import warnings
 from collections.abc import AsyncIterator, Iterator, Sequence
 from importlib import util
-from typing import (
-    Any,
-    Callable,
-    Literal,
-    Optional,
-    Union,
-    cast,
-    overload,
-)
+from typing import Any, Callable, Literal, Optional, Union, cast, overload
 
 from langchain_core.language_models import (
     BaseChatModel,
@@ -27,16 +19,17 @@ from langchain_core.runnables import Runnable, RunnableConfig, ensure_config
 from langchain_core.runnables.schema import StreamEvent
 from langchain_core.tools import BaseTool
 from langchain_core.tracers import RunLog, RunLogPatch
+from langchain_core.v1.chat_models import BaseChatModel as BaseChatModelV1
 from pydantic import BaseModel
-from typing_extensions import TypeAlias
+from typing_extensions import TypeAlias, override
 
 __all__ = [
-    "init_chat_model",
     # For backwards compatibility
     "BaseChatModel",
     "SimpleChatModel",
-    "generate_from_stream",
     "agenerate_from_stream",
+    "generate_from_stream",
+    "init_chat_model",
 ]
 
 
@@ -47,10 +40,23 @@ def init_chat_model(
     model_provider: Optional[str] = None,
     configurable_fields: Literal[None] = None,
     config_prefix: Optional[str] = None,
+    message_version: Literal["v0"] = "v0",
     **kwargs: Any,
 ) -> BaseChatModel: ...
 
 
+@overload
+def init_chat_model(
+    model: str,
+    *,
+    model_provider: Optional[str] = None,
+    configurable_fields: Literal[None] = None,
+    config_prefix: Optional[str] = None,
+    message_version: Literal["v1"] = "v1",
+    **kwargs: Any,
+) -> BaseChatModelV1: ...
+
+
 @overload
 def init_chat_model(
     model: Literal[None] = None,
@@ -58,6 +64,7 @@ def init_chat_model(
     model_provider: Optional[str] = None,
     configurable_fields: Literal[None] = None,
     config_prefix: Optional[str] = None,
+    message_version: Literal["v0", "v1"] = "v0",
     **kwargs: Any,
 ) -> _ConfigurableModel: ...
 
@@ -69,6 +76,7 @@ def init_chat_model(
     model_provider: Optional[str] = None,
     configurable_fields: Union[Literal["any"], list[str], tuple[str, ...]] = ...,
     config_prefix: Optional[str] = None,
+    message_version: Literal["v0", "v1"] = "v0",
     **kwargs: Any,
 ) -> _ConfigurableModel: ...
 
@@ -84,61 +92,77 @@ def init_chat_model(
         Union[Literal["any"], list[str], tuple[str, ...]]
     ] = None,
     config_prefix: Optional[str] = None,
+    message_version: Literal["v0", "v1"] = "v0",
     **kwargs: Any,
-) -> Union[BaseChatModel, _ConfigurableModel]:
-    """Initialize a ChatModel from the model name and provider.
+) -> Union[BaseChatModel, BaseChatModelV1, _ConfigurableModel]:
+    """Initialize a ChatModel in a single line using the model's name and provider.
 
-    **Note:** Must have the integration package corresponding to the model provider
-    installed.
+    .. note::
+        Must have the integration package corresponding to the model provider installed.
+        You should look at the `provider integration's API reference <https://python.langchain.com/api_reference/reference.html#integrations>`__
+        to see what parameters are supported by the model.
 
     Args:
-        model: The name of the model, e.g. "o3-mini", "claude-3-5-sonnet-latest". You can
+        model: The name of the model, e.g. ``'o3-mini'``, ``'claude-3-5-sonnet-latest'``. You can
             also specify model and model provider in a single argument using
-            '{model_provider}:{model}' format, e.g. "openai:o1".
+            ``'{model_provider}:{model}'`` format, e.g. ``'openai:o1'``.
         model_provider: The model provider if not specified as part of model arg (see
             above). Supported model_provider values and the corresponding integration
             package are:
 
-            - 'openai'              -> langchain-openai
-            - 'anthropic'           -> langchain-anthropic
-            - 'azure_openai'        -> langchain-openai
-            - 'azure_ai'            -> langchain-azure-ai
-            - 'google_vertexai'     -> langchain-google-vertexai
-            - 'google_genai'        -> langchain-google-genai
-            - 'bedrock'             -> langchain-aws
-            - 'bedrock_converse'    -> langchain-aws
-            - 'cohere'              -> langchain-cohere
-            - 'fireworks'           -> langchain-fireworks
-            - 'together'            -> langchain-together
-            - 'mistralai'           -> langchain-mistralai
-            - 'huggingface'         -> langchain-huggingface
-            - 'groq'                -> langchain-groq
-            - 'ollama'              -> langchain-ollama
-            - 'google_anthropic_vertex'    -> langchain-google-vertexai
-            - 'deepseek'            -> langchain-deepseek
-            - 'ibm'                 -> langchain-ibm
-            - 'nvidia'              -> langchain-nvidia-ai-endpoints
-            - 'xai'                 -> langchain-xai
-            - 'perplexity'          -> langchain-perplexity
+            - ``openai``              -> ``langchain-openai``
+            - ``anthropic``           -> ``langchain-anthropic``
+            - ``azure_openai``        -> ``langchain-openai``
+            - ``azure_ai``            -> ``langchain-azure-ai``
+            - ``google_vertexai``     -> ``langchain-google-vertexai``
+            - ``google_genai``        -> ``langchain-google-genai``
+            - ``bedrock``             -> ``langchain-aws``
+            - ``bedrock_converse``    -> ``langchain-aws``
+            - ``cohere``              -> ``langchain-cohere``
+            - ``fireworks``           -> ``langchain-fireworks``
+            - ``together``            -> ``langchain-together``
+            - ``mistralai``           -> ``langchain-mistralai``
+            - ``huggingface``         -> ``langchain-huggingface``
+            - ``groq``                -> ``langchain-groq``
+            - ``ollama``              -> ``langchain-ollama``
+            - ``google_anthropic_vertex``    -> ``langchain-google-vertexai``
+            - ``deepseek``            -> ``langchain-deepseek``
+            - ``ibm``                 -> ``langchain-ibm``
+            - ``nvidia``              -> ``langchain-nvidia-ai-endpoints``
+            - ``xai``                 -> ``langchain-xai``
+            - ``perplexity``          -> ``langchain-perplexity``
 
             Will attempt to infer model_provider from model if not specified. The
             following providers will be inferred based on these model prefixes:
 
-            - 'gpt-3...' | 'gpt-4...' | 'o1...' -> 'openai'
-            - 'claude...'                       -> 'anthropic'
-            - 'amazon....'                      -> 'bedrock'
-            - 'gemini...'                       -> 'google_vertexai'
-            - 'command...'                      -> 'cohere'
-            - 'accounts/fireworks...'           -> 'fireworks'
-            - 'mistral...'                      -> 'mistralai'
-            - 'deepseek...'                     -> 'deepseek'
-            - 'grok...'                         -> 'xai'
-            - 'sonar...'                        -> 'perplexity'
-        configurable_fields: Which model parameters are
-            configurable:
+            - ``gpt-3...`` | ``gpt-4...`` | ``o1...`` -> ``openai``
+            - ``claude...``                       -> ``anthropic``
+            - ``amazon...``                       -> ``bedrock``
+            - ``gemini...``                       -> ``google_vertexai``
+            - ``command...``                      -> ``cohere``
+            - ``accounts/fireworks...``           -> ``fireworks``
+            - ``mistral...``                      -> ``mistralai``
+            - ``deepseek...``                     -> ``deepseek``
+            - ``grok...``                         -> ``xai``
+            - ``sonar...``                        -> ``perplexity``
+
+        message_version: The version of the BaseChatModel to return. Either ``"v0"`` for
+            a v0 :class:`~langchain_core.language_models.chat_models.BaseChatModel` or
+            ``"v1"`` for a v1 :class:`~langchain_core.v1.chat_models.BaseChatModel`. The
+            output version determines what type of message objects the model will
+            generate.
+
+            .. note::
+                Currently supported for these providers:
+
+                - ``openai``
+
+            .. versionadded:: 0.4.0
+
+        configurable_fields: Which model parameters are configurable:
 
             - None: No configurable fields.
-            - "any": All fields are configurable. *See Security Note below.*
+            - ``'any'``: All fields are configurable. **See Security Note below.**
             - Union[List[str], Tuple[str, ...]]: Specified fields are configurable.
 
             Fields are assumed to have config_prefix stripped if there is a
@@ -146,15 +170,15 @@ def init_chat_model(
             not specified, then defaults to ``("model", "model_provider")``.
 
             ***Security Note***: Setting ``configurable_fields="any"`` means fields like
-            api_key, base_url, etc. can be altered at runtime, potentially redirecting
+            ``api_key``, ``base_url``, etc. can be altered at runtime, potentially redirecting
             model requests to a different service/user. Make sure that if you're
             accepting untrusted configurations that you enumerate the
             ``configurable_fields=(...)`` explicitly.
 
-        config_prefix: If config_prefix is a non-empty string then model will be
+        config_prefix: If ``'config_prefix'`` is a non-empty string then model will be
             configurable at runtime via the
             ``config["configurable"]["{config_prefix}_{param}"]`` keys. If
-            config_prefix is an empty string then model will be configurable via
+            ``'config_prefix'`` is an empty string then model will be configurable via
             ``config["configurable"]["{param}"]``.
         temperature: Model temperature.
         max_tokens: Max output tokens.
@@ -187,7 +211,7 @@ def init_chat_model(
 
             o3_mini = init_chat_model("openai:o3-mini", temperature=0)
             claude_sonnet = init_chat_model("anthropic:claude-3-5-sonnet-latest", temperature=0)
-            gemini_2_flash = init_chat_model("google_vertexai:gemini-2.0-flash", temperature=0)
+            gemini_2_flash = init_chat_model("google_vertexai:gemini-2.5-flash", temperature=0)
 
             o3_mini.invoke("what's your name")
             claude_sonnet.invoke("what's your name")
@@ -315,70 +339,89 @@ def init_chat_model(
         warnings.warn(
             f"{config_prefix=} has been set but no fields are configurable. Set "
             f"`configurable_fields=(...)` to specify the model params that are "
-            f"configurable."
+            f"configurable.",
+            stacklevel=2,
         )
 
     if not configurable_fields:
         return _init_chat_model_helper(
-            cast(str, model), model_provider=model_provider, **kwargs
-        )
-    else:
-        if model:
-            kwargs["model"] = model
-        if model_provider:
-            kwargs["model_provider"] = model_provider
-        return _ConfigurableModel(
-            default_config=kwargs,
-            config_prefix=config_prefix,
-            configurable_fields=configurable_fields,
+            cast("str", model),
+            model_provider=model_provider,
+            message_version=message_version,
+            **kwargs,
         )
+    if model:
+        kwargs["model"] = model
+    if model_provider:
+        kwargs["model_provider"] = model_provider
+    return _ConfigurableModel(
+        default_config=kwargs,
+        config_prefix=config_prefix,
+        configurable_fields=configurable_fields,
+    )
 
 
 def _init_chat_model_helper(
-    model: str, *, model_provider: Optional[str] = None, **kwargs: Any
-) -> BaseChatModel:
+    model: str,
+    *,
+    model_provider: Optional[str] = None,
+    message_version: Literal["v0", "v1"] = "v0",
+    **kwargs: Any,
+) -> Union[BaseChatModel, BaseChatModelV1]:
     model, model_provider = _parse_model(model, model_provider)
+    if message_version != "v0" and model_provider not in ("openai",):
+        warnings.warn(
+            f"Model provider {model_provider} does not support "
+            f"message_version={message_version}. Defaulting to v0.",
+            stacklevel=2,
+        )
     if model_provider == "openai":
         _check_pkg("langchain_openai")
-        from langchain_openai import ChatOpenAI
+        if message_version == "v0":
+            from langchain_openai import ChatOpenAI
 
-        return ChatOpenAI(model=model, **kwargs)
-    elif model_provider == "anthropic":
+            return ChatOpenAI(model=model, **kwargs)
+        # v1
+        from langchain_openai.v1 import ChatOpenAI as ChatOpenAIV1
+
+        return ChatOpenAIV1(model=model, **kwargs)
+
+    if model_provider == "anthropic":
         _check_pkg("langchain_anthropic")
         from langchain_anthropic import ChatAnthropic
 
         return ChatAnthropic(model=model, **kwargs)  # type: ignore[call-arg,unused-ignore]
-    elif model_provider == "azure_openai":
+    if model_provider == "azure_openai":
         _check_pkg("langchain_openai")
         from langchain_openai import AzureChatOpenAI
 
         return AzureChatOpenAI(model=model, **kwargs)
-    elif model_provider == "azure_ai":
+    if model_provider == "azure_ai":
         _check_pkg("langchain_azure_ai")
         from langchain_azure_ai.chat_models import AzureAIChatCompletionsModel
 
         return AzureAIChatCompletionsModel(model=model, **kwargs)
-    elif model_provider == "cohere":
+    if model_provider == "cohere":
         _check_pkg("langchain_cohere")
         from langchain_cohere import ChatCohere
 
         return ChatCohere(model=model, **kwargs)
-    elif model_provider == "google_vertexai":
+    if model_provider == "google_vertexai":
         _check_pkg("langchain_google_vertexai")
         from langchain_google_vertexai import ChatVertexAI
 
         return ChatVertexAI(model=model, **kwargs)
-    elif model_provider == "google_genai":
+    if model_provider == "google_genai":
         _check_pkg("langchain_google_genai")
         from langchain_google_genai import ChatGoogleGenerativeAI
 
         return ChatGoogleGenerativeAI(model=model, **kwargs)
-    elif model_provider == "fireworks":
+    if model_provider == "fireworks":
         _check_pkg("langchain_fireworks")
         from langchain_fireworks import ChatFireworks
 
         return ChatFireworks(model=model, **kwargs)
-    elif model_provider == "ollama":
+    if model_provider == "ollama":
         try:
             _check_pkg("langchain_ollama")
             from langchain_ollama import ChatOllama
@@ -393,73 +436,72 @@ def _init_chat_model_helper(
                 _check_pkg("langchain_ollama")
 
         return ChatOllama(model=model, **kwargs)
-    elif model_provider == "together":
+    if model_provider == "together":
         _check_pkg("langchain_together")
         from langchain_together import ChatTogether
 
         return ChatTogether(model=model, **kwargs)
-    elif model_provider == "mistralai":
+    if model_provider == "mistralai":
         _check_pkg("langchain_mistralai")
         from langchain_mistralai import ChatMistralAI
 
         return ChatMistralAI(model=model, **kwargs)  # type: ignore[call-arg,unused-ignore]
-    elif model_provider == "huggingface":
+    if model_provider == "huggingface":
         _check_pkg("langchain_huggingface")
         from langchain_huggingface import ChatHuggingFace
 
         return ChatHuggingFace(model_id=model, **kwargs)
-    elif model_provider == "groq":
+    if model_provider == "groq":
         _check_pkg("langchain_groq")
         from langchain_groq import ChatGroq
 
         return ChatGroq(model=model, **kwargs)
-    elif model_provider == "bedrock":
+    if model_provider == "bedrock":
         _check_pkg("langchain_aws")
         from langchain_aws import ChatBedrock
 
         # TODO: update to use model= once ChatBedrock supports
         return ChatBedrock(model_id=model, **kwargs)
-    elif model_provider == "bedrock_converse":
+    if model_provider == "bedrock_converse":
         _check_pkg("langchain_aws")
         from langchain_aws import ChatBedrockConverse
 
         return ChatBedrockConverse(model=model, **kwargs)
-    elif model_provider == "google_anthropic_vertex":
+    if model_provider == "google_anthropic_vertex":
         _check_pkg("langchain_google_vertexai")
         from langchain_google_vertexai.model_garden import ChatAnthropicVertex
 
         return ChatAnthropicVertex(model=model, **kwargs)
-    elif model_provider == "deepseek":
+    if model_provider == "deepseek":
         _check_pkg("langchain_deepseek", pkg_kebab="langchain-deepseek")
         from langchain_deepseek import ChatDeepSeek
 
         return ChatDeepSeek(model=model, **kwargs)
-    elif model_provider == "nvidia":
+    if model_provider == "nvidia":
         _check_pkg("langchain_nvidia_ai_endpoints")
         from langchain_nvidia_ai_endpoints import ChatNVIDIA
 
         return ChatNVIDIA(model=model, **kwargs)
-    elif model_provider == "ibm":
+    if model_provider == "ibm":
         _check_pkg("langchain_ibm")
         from langchain_ibm import ChatWatsonx
 
         return ChatWatsonx(model_id=model, **kwargs)
-    elif model_provider == "xai":
+    if model_provider == "xai":
         _check_pkg("langchain_xai")
         from langchain_xai import ChatXAI
 
         return ChatXAI(model=model, **kwargs)
-    elif model_provider == "perplexity":
+    if model_provider == "perplexity":
         _check_pkg("langchain_perplexity")
         from langchain_perplexity import ChatPerplexity
 
         return ChatPerplexity(model=model, **kwargs)
-    else:
-        supported = ", ".join(_SUPPORTED_PROVIDERS)
-        raise ValueError(
-            f"Unsupported {model_provider=}.\n\nSupported model providers are: "
-            f"{supported}"
-        )
+    supported = ", ".join(_SUPPORTED_PROVIDERS)
+    msg = (
+        f"Unsupported {model_provider=}.\n\nSupported model providers are: {supported}"
+    )
+    raise ValueError(msg)
 
 
 _SUPPORTED_PROVIDERS = {
@@ -489,26 +531,25 @@ _SUPPORTED_PROVIDERS = {
 def _attempt_infer_model_provider(model_name: str) -> Optional[str]:
     if any(model_name.startswith(pre) for pre in ("gpt-3", "gpt-4", "o1", "o3")):
         return "openai"
-    elif model_name.startswith("claude"):
+    if model_name.startswith("claude"):
         return "anthropic"
-    elif model_name.startswith("command"):
+    if model_name.startswith("command"):
         return "cohere"
-    elif model_name.startswith("accounts/fireworks"):
+    if model_name.startswith("accounts/fireworks"):
         return "fireworks"
-    elif model_name.startswith("gemini"):
+    if model_name.startswith("gemini"):
         return "google_vertexai"
-    elif model_name.startswith("amazon."):
+    if model_name.startswith("amazon."):
         return "bedrock"
-    elif model_name.startswith("mistral"):
+    if model_name.startswith("mistral"):
         return "mistralai"
-    elif model_name.startswith("deepseek"):
+    if model_name.startswith("deepseek"):
         return "deepseek"
-    elif model_name.startswith("grok"):
+    if model_name.startswith("grok"):
         return "xai"
-    elif model_name.startswith("sonar"):
+    if model_name.startswith("sonar"):
         return "perplexity"
-    else:
-        return None
+    return None
 
 
 def _parse_model(model: str, model_provider: Optional[str]) -> tuple[str, str]:
@@ -521,10 +562,11 @@ def _parse_model(model: str, model_provider: Optional[str]) -> tuple[str, str]:
         model = ":".join(model.split(":")[1:])
     model_provider = model_provider or _attempt_infer_model_provider(model)
     if not model_provider:
-        raise ValueError(
+        msg = (
             f"Unable to infer model provider for {model=}, please specify "
             f"model_provider directly."
         )
+        raise ValueError(msg)
     model_provider = model_provider.replace("-", "_").lower()
     return model, model_provider
 
@@ -532,9 +574,10 @@ def _parse_model(model: str, model_provider: Optional[str]) -> tuple[str, str]:
 def _check_pkg(pkg: str, *, pkg_kebab: Optional[str] = None) -> None:
     if not util.find_spec(pkg):
         pkg_kebab = pkg_kebab if pkg_kebab is not None else pkg.replace("_", "-")
-        raise ImportError(
+        msg = (
             f"Unable to import {pkg}. Please install with `pip install -U {pkg_kebab}`"
         )
+        raise ImportError(msg)
 
 
 def _remove_prefix(s: str, prefix: str) -> str:
@@ -567,7 +610,7 @@ class _ConfigurableModel(Runnable[LanguageModelInput, Any]):
             else config_prefix
         )
         self._queued_declarative_operations: list[tuple[str, tuple, dict]] = list(
-            queued_declarative_operations
+            queued_declarative_operations,
         )
 
     def __getattr__(self, name: str) -> Any:
@@ -579,7 +622,7 @@ class _ConfigurableModel(Runnable[LanguageModelInput, Any]):
             # self._model()).
             def queue(*args: Any, **kwargs: Any) -> _ConfigurableModel:
                 queued_declarative_operations = list(
-                    self._queued_declarative_operations
+                    self._queued_declarative_operations,
                 )
                 queued_declarative_operations.append((name, args, kwargs))
                 return _ConfigurableModel(
@@ -592,14 +635,13 @@ class _ConfigurableModel(Runnable[LanguageModelInput, Any]):
                 )
 
             return queue
-        elif self._default_config and (model := self._model()) and hasattr(model, name):
+        if self._default_config and (model := self._model()) and hasattr(model, name):
             return getattr(model, name)
-        else:
-            msg = f"{name} is not a BaseChatModel attribute"
-            if self._default_config:
-                msg += " and is not implemented on the default model"
-            msg += "."
-            raise AttributeError(msg)
+        msg = f"{name} is not a BaseChatModel attribute"
+        if self._default_config:
+            msg += " and is not implemented on the default model"
+        msg += "."
+        raise AttributeError(msg)
 
     def _model(self, config: Optional[RunnableConfig] = None) -> Runnable:
         params = {**self._default_config, **self._model_params(config)}
@@ -627,7 +669,7 @@ class _ConfigurableModel(Runnable[LanguageModelInput, Any]):
         **kwargs: Any,
     ) -> _ConfigurableModel:
         """Bind config to a Runnable, returning a new Runnable."""
-        config = RunnableConfig(**(config or {}), **cast(RunnableConfig, kwargs))
+        config = RunnableConfig(**(config or {}), **cast("RunnableConfig", kwargs))
         model_params = self._model_params(config)
         remaining_config = {k: v for k, v in config.items() if k != "configurable"}
         remaining_config["configurable"] = {
@@ -642,7 +684,7 @@ class _ConfigurableModel(Runnable[LanguageModelInput, Any]):
                     "with_config",
                     (),
                     {"config": remaining_config},
-                )
+                ),
             )
         return _ConfigurableModel(
             default_config={**self._default_config, **model_params},
@@ -670,6 +712,7 @@ class _ConfigurableModel(Runnable[LanguageModelInput, Any]):
             list[AnyMessage],
         ]
 
+    @override
     def invoke(
         self,
         input: LanguageModelInput,
@@ -678,6 +721,7 @@ class _ConfigurableModel(Runnable[LanguageModelInput, Any]):
     ) -> Any:
         return self._model(config).invoke(input, config=config, **kwargs)
 
+    @override
     async def ainvoke(
         self,
         input: LanguageModelInput,
@@ -686,6 +730,7 @@ class _ConfigurableModel(Runnable[LanguageModelInput, Any]):
     ) -> Any:
         return await self._model(config).ainvoke(input, config=config, **kwargs)
 
+    @override
     def stream(
         self,
         input: LanguageModelInput,
@@ -694,6 +739,7 @@ class _ConfigurableModel(Runnable[LanguageModelInput, Any]):
     ) -> Iterator[Any]:
         yield from self._model(config).stream(input, config=config, **kwargs)
 
+    @override
     async def astream(
         self,
         input: LanguageModelInput,
@@ -717,14 +763,19 @@ class _ConfigurableModel(Runnable[LanguageModelInput, Any]):
             if isinstance(config, list):
                 config = config[0]
             return self._model(config).batch(
-                inputs, config=config, return_exceptions=return_exceptions, **kwargs
+                inputs,
+                config=config,
+                return_exceptions=return_exceptions,
+                **kwargs,
             )
         # If multiple configs default to Runnable.batch which uses executor to invoke
         # in parallel.
-        else:
-            return super().batch(
-                inputs, config=config, return_exceptions=return_exceptions, **kwargs
-            )
+        return super().batch(
+            inputs,
+            config=config,
+            return_exceptions=return_exceptions,
+            **kwargs,
+        )
 
     async def abatch(
         self,
@@ -740,14 +791,19 @@ class _ConfigurableModel(Runnable[LanguageModelInput, Any]):
             if isinstance(config, list):
                 config = config[0]
             return await self._model(config).abatch(
-                inputs, config=config, return_exceptions=return_exceptions, **kwargs
+                inputs,
+                config=config,
+                return_exceptions=return_exceptions,
+                **kwargs,
             )
         # If multiple configs default to Runnable.batch which uses executor to invoke
         # in parallel.
-        else:
-            return await super().abatch(
-                inputs, config=config, return_exceptions=return_exceptions, **kwargs
-            )
+        return await super().abatch(
+            inputs,
+            config=config,
+            return_exceptions=return_exceptions,
+            **kwargs,
+        )
 
     def batch_as_completed(
         self,
@@ -762,14 +818,20 @@ class _ConfigurableModel(Runnable[LanguageModelInput, Any]):
         if config is None or isinstance(config, dict) or len(config) <= 1:
             if isinstance(config, list):
                 config = config[0]
-            yield from self._model(cast(RunnableConfig, config)).batch_as_completed(  # type: ignore[call-overload]
-                inputs, config=config, return_exceptions=return_exceptions, **kwargs
+            yield from self._model(cast("RunnableConfig", config)).batch_as_completed(  # type: ignore[call-overload]
+                inputs,
+                config=config,
+                return_exceptions=return_exceptions,
+                **kwargs,
             )
         # If multiple configs default to Runnable.batch which uses executor to invoke
         # in parallel.
         else:
             yield from super().batch_as_completed(  # type: ignore[call-overload]
-                inputs, config=config, return_exceptions=return_exceptions, **kwargs
+                inputs,
+                config=config,
+                return_exceptions=return_exceptions,
+                **kwargs,
             )
 
     async def abatch_as_completed(
@@ -786,19 +848,26 @@ class _ConfigurableModel(Runnable[LanguageModelInput, Any]):
             if isinstance(config, list):
                 config = config[0]
             async for x in self._model(
-                cast(RunnableConfig, config)
+                cast("RunnableConfig", config),
             ).abatch_as_completed(  # type: ignore[call-overload]
-                inputs, config=config, return_exceptions=return_exceptions, **kwargs
+                inputs,
+                config=config,
+                return_exceptions=return_exceptions,
+                **kwargs,
             ):
                 yield x
         # If multiple configs default to Runnable.batch which uses executor to invoke
         # in parallel.
         else:
             async for x in super().abatch_as_completed(  # type: ignore[call-overload]
-                inputs, config=config, return_exceptions=return_exceptions, **kwargs
+                inputs,
+                config=config,
+                return_exceptions=return_exceptions,
+                **kwargs,
             ):
                 yield x
 
+    @override
     def transform(
         self,
         input: Iterator[LanguageModelInput],
@@ -807,6 +876,7 @@ class _ConfigurableModel(Runnable[LanguageModelInput, Any]):
     ) -> Iterator[Any]:
         yield from self._model(config).transform(input, config=config, **kwargs)
 
+    @override
     async def atransform(
         self,
         input: AsyncIterator[LanguageModelInput],
@@ -850,6 +920,7 @@ class _ConfigurableModel(Runnable[LanguageModelInput, Any]):
         **kwargs: Any,
     ) -> AsyncIterator[RunLog]: ...
 
+    @override
     async def astream_log(
         self,
         input: Any,
@@ -880,6 +951,7 @@ class _ConfigurableModel(Runnable[LanguageModelInput, Any]):
         ):
             yield x
 
+    @override
     async def astream_events(
         self,
         input: Any,
@@ -918,6 +990,8 @@ class _ConfigurableModel(Runnable[LanguageModelInput, Any]):
 
     # Explicitly added to satisfy downstream linters.
     def with_structured_output(
-        self, schema: Union[dict, type[BaseModel]], **kwargs: Any
+        self,
+        schema: Union[dict, type[BaseModel]],
+        **kwargs: Any,
     ) -> Runnable[LanguageModelInput, Union[dict, BaseModel]]:
         return self.__getattr__("with_structured_output")(schema, **kwargs)