langchain-core 1.0.0a5__py3-none-any.whl → 1.0.3__py3-none-any.whl

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
 
@@ -7,21 +10,17 @@ import functools
 import inspect
 import json
 import logging
-import warnings
 from abc import ABC, abstractmethod
-from collections.abc import AsyncIterator, Iterator, Sequence
+from collections.abc import AsyncIterator, Callable, Iterator, Sequence
 from pathlib import Path
 from typing import (
     TYPE_CHECKING,
     Any,
-    Callable,
-    Optional,
-    Union,
     cast,
 )
 
 import yaml
-from pydantic import ConfigDict, Field, model_validator
+from pydantic import ConfigDict
 from tenacity import (
     RetryCallState,
     before_sleep_log,
@@ -33,7 +32,6 @@ from tenacity import (
 )
 from typing_extensions import override
 
-from langchain_core._api import deprecated
 from langchain_core.caches import BaseCache
 from langchain_core.callbacks import (
     AsyncCallbackManager,
@@ -51,10 +49,7 @@ from langchain_core.language_models.base import (
 )
 from langchain_core.load import dumpd
 from langchain_core.messages import (
-    AIMessage,
-    BaseMessage,
     convert_to_messages,
-    get_buffer_string,
 )
 from langchain_core.outputs import Generation, GenerationChunk, LLMResult, RunInfo
 from langchain_core.prompt_values import ChatPromptValue, PromptValue, StringPromptValue
@@ -76,16 +71,14 @@ def _log_error_once(msg: str) -> None:
 def create_base_retry_decorator(
     error_types: list[type[BaseException]],
     max_retries: int = 1,
-    run_manager: Optional[
-        Union[AsyncCallbackManagerForLLMRun, CallbackManagerForLLMRun]
-    ] = None,
+    run_manager: AsyncCallbackManagerForLLMRun | CallbackManagerForLLMRun | None = None,
 ) -> Callable[[Any], Any]:
     """Create a retry decorator for a given LLM and provided a list of error types.
 
     Args:
         error_types: List of error types to retry on.
-        max_retries: Number of retries. Default is 1.
-        run_manager: Callback manager for the run. Default is None.
+        max_retries: Number of retries.
+        run_manager: Callback manager for the run.
 
     Returns:
         A retry decorator.
@@ -101,13 +94,17 @@ def create_base_retry_decorator(
             if isinstance(run_manager, AsyncCallbackManagerForLLMRun):
                 coro = run_manager.on_retry(retry_state)
                 try:
-                    loop = asyncio.get_event_loop()
-                    if loop.is_running():
-                        # TODO: Fix RUF006 - this task should have a reference
-                        #  and be awaited somewhere
-                        loop.create_task(coro)  # noqa: RUF006
-                    else:
+                    try:
+                        loop = asyncio.get_event_loop()
+                    except RuntimeError:
                         asyncio.run(coro)
+                    else:
+                        if loop.is_running():
+                            # TODO: Fix RUF006 - this task should have a reference
+                            #  and be awaited somewhere
+                            loop.create_task(coro)  # noqa: RUF006
+                        else:
+                            asyncio.run(coro)
                 except Exception as e:
                     _log_error_once(f"Error in on_retry: {e}")
             else:
@@ -129,9 +126,9 @@ def create_base_retry_decorator(
     )
 
 
-def _resolve_cache(*, cache: Union[BaseCache, bool, None]) -> Optional[BaseCache]:
+def _resolve_cache(*, cache: BaseCache | bool | None) -> BaseCache | None:
     """Resolve the cache."""
-    llm_cache: Optional[BaseCache]
+    llm_cache: BaseCache | None
     if isinstance(cache, BaseCache):
         llm_cache = cache
     elif cache is None:
@@ -156,14 +153,14 @@ def _resolve_cache(*, cache: Union[BaseCache, bool, None]) -> Optional[BaseCache
 def get_prompts(
     params: dict[str, Any],
     prompts: list[str],
-    cache: Union[BaseCache, bool, None] = None,  # noqa: FBT001
+    cache: BaseCache | bool | None = None,  # noqa: FBT001
 ) -> tuple[dict[int, list], str, list[int], list[str]]:
     """Get prompts that are already cached.
 
     Args:
         params: Dictionary of parameters.
         prompts: List of prompts.
-        cache: Cache object. Default is None.
+        cache: Cache object.
 
     Returns:
         A tuple of existing prompts, llm_string, missing prompt indexes,
@@ -192,14 +189,14 @@ def get_prompts(
 async def aget_prompts(
     params: dict[str, Any],
     prompts: list[str],
-    cache: Union[BaseCache, bool, None] = None,  # noqa: FBT001
+    cache: BaseCache | bool | None = None,  # noqa: FBT001
 ) -> tuple[dict[int, list], str, list[int], list[str]]:
     """Get prompts that are already cached. Async version.
 
     Args:
         params: Dictionary of parameters.
         prompts: List of prompts.
-        cache: Cache object. Default is None.
+        cache: Cache object.
 
     Returns:
         A tuple of existing prompts, llm_string, missing prompt indexes,
@@ -225,13 +222,13 @@ async def aget_prompts(
 
 
 def update_cache(
-    cache: Union[BaseCache, bool, None],  # noqa: FBT001
+    cache: BaseCache | bool | None,  # noqa: FBT001
     existing_prompts: dict[int, list],
     llm_string: str,
     missing_prompt_idxs: list[int],
     new_results: LLMResult,
     prompts: list[str],
-) -> Optional[dict]:
+) -> dict | None:
     """Update the cache and get the LLM output.
 
     Args:
@@ -258,13 +255,13 @@ def update_cache(
 
 
 async def aupdate_cache(
-    cache: Union[BaseCache, bool, None],  # noqa: FBT001
+    cache: BaseCache | bool | None,  # noqa: FBT001
     existing_prompts: dict[int, list],
     llm_string: str,
     missing_prompt_idxs: list[int],
     new_results: LLMResult,
     prompts: list[str],
-) -> Optional[dict]:
+) -> dict | None:
     """Update the cache and get the LLM output. Async version.
 
     Args:
@@ -296,26 +293,10 @@ class BaseLLM(BaseLanguageModel[str], ABC):
     It should take in a prompt and return a string.
     """
 
-    callback_manager: Optional[BaseCallbackManager] = Field(default=None, exclude=True)
-    """[DEPRECATED]"""
-
     model_config = ConfigDict(
         arbitrary_types_allowed=True,
     )
 
-    @model_validator(mode="before")
-    @classmethod
-    def raise_deprecation(cls, values: dict) -> Any:
-        """Raise deprecation warning if callback_manager is used."""
-        if values.get("callback_manager") is not None:
-            warnings.warn(
-                "callback_manager is deprecated. Please use callbacks instead.",
-                DeprecationWarning,
-                stacklevel=5,
-            )
-            values["callbacks"] = values.pop("callback_manager", None)
-        return values
-
     @functools.cached_property
     def _serialized(self) -> dict[str, Any]:
         return dumpd(self)
@@ -325,7 +306,7 @@ class BaseLLM(BaseLanguageModel[str], ABC):
     @property
     @override
     def OutputType(self) -> type[str]:
-        """Get the input type for this runnable."""
+        """Get the input type for this `Runnable`."""
         return str
 
     def _convert_input(self, model_input: LanguageModelInput) -> PromptValue:
@@ -343,7 +324,7 @@ class BaseLLM(BaseLanguageModel[str], ABC):
 
     def _get_ls_params(
         self,
-        stop: Optional[list[str]] = None,
+        stop: list[str] | None = None,
         **kwargs: Any,
     ) -> LangSmithParams:
         """Get standard params for tracing."""
@@ -382,9 +363,9 @@ class BaseLLM(BaseLanguageModel[str], ABC):
     def invoke(
         self,
         input: LanguageModelInput,
-        config: Optional[RunnableConfig] = None,
+        config: RunnableConfig | None = None,
         *,
-        stop: Optional[list[str]] = None,
+        stop: list[str] | None = None,
         **kwargs: Any,
     ) -> str:
         config = ensure_config(config)
@@ -407,9 +388,9 @@ class BaseLLM(BaseLanguageModel[str], ABC):
     async def ainvoke(
         self,
         input: LanguageModelInput,
-        config: Optional[RunnableConfig] = None,
+        config: RunnableConfig | None = None,
         *,
-        stop: Optional[list[str]] = None,
+        stop: list[str] | None = None,
         **kwargs: Any,
     ) -> str:
         config = ensure_config(config)
@@ -429,7 +410,7 @@ class BaseLLM(BaseLanguageModel[str], ABC):
     def batch(
         self,
         inputs: list[LanguageModelInput],
-        config: Optional[Union[RunnableConfig, list[RunnableConfig]]] = None,
+        config: RunnableConfig | list[RunnableConfig] | None = None,
         *,
         return_exceptions: bool = False,
         **kwargs: Any,
@@ -476,7 +457,7 @@ class BaseLLM(BaseLanguageModel[str], ABC):
     async def abatch(
         self,
         inputs: list[LanguageModelInput],
-        config: Optional[Union[RunnableConfig, list[RunnableConfig]]] = None,
+        config: RunnableConfig | list[RunnableConfig] | None = None,
         *,
         return_exceptions: bool = False,
         **kwargs: Any,
@@ -522,9 +503,9 @@ class BaseLLM(BaseLanguageModel[str], ABC):
     def stream(
         self,
         input: LanguageModelInput,
-        config: Optional[RunnableConfig] = None,
+        config: RunnableConfig | None = None,
         *,
-        stop: Optional[list[str]] = None,
+        stop: list[str] | None = None,
         **kwargs: Any,
     ) -> Iterator[str]:
         if type(self)._stream == BaseLLM._stream:  # noqa: SLF001
@@ -559,7 +540,7 @@ class BaseLLM(BaseLanguageModel[str], ABC):
                 run_id=config.pop("run_id", None),
                 batch_size=1,
             )
-            generation: Optional[GenerationChunk] = None
+            generation: GenerationChunk | None = None
             try:
                 for chunk in self._stream(
                     prompt, stop=stop, run_manager=run_manager, **kwargs
@@ -589,9 +570,9 @@ class BaseLLM(BaseLanguageModel[str], ABC):
     async def astream(
         self,
         input: LanguageModelInput,
-        config: Optional[RunnableConfig] = None,
+        config: RunnableConfig | None = None,
         *,
-        stop: Optional[list[str]] = None,
+        stop: list[str] | None = None,
         **kwargs: Any,
     ) -> AsyncIterator[str]:
         if (
@@ -629,7 +610,7 @@ class BaseLLM(BaseLanguageModel[str], ABC):
             run_id=config.pop("run_id", None),
             batch_size=1,
         )
-        generation: Optional[GenerationChunk] = None
+        generation: GenerationChunk | None = None
         try:
             async for chunk in self._astream(
                 prompt,
@@ -662,8 +643,8 @@ class BaseLLM(BaseLanguageModel[str], ABC):
     def _generate(
         self,
         prompts: list[str],
-        stop: Optional[list[str]] = None,
-        run_manager: Optional[CallbackManagerForLLMRun] = None,
+        stop: list[str] | None = None,
+        run_manager: CallbackManagerForLLMRun | None = None,
         **kwargs: Any,
     ) -> LLMResult:
         """Run the LLM on the given prompts.
@@ -682,8 +663,8 @@ class BaseLLM(BaseLanguageModel[str], ABC):
     async def _agenerate(
         self,
         prompts: list[str],
-        stop: Optional[list[str]] = None,
-        run_manager: Optional[AsyncCallbackManagerForLLMRun] = None,
+        stop: list[str] | None = None,
+        run_manager: AsyncCallbackManagerForLLMRun | None = None,
         **kwargs: Any,
     ) -> LLMResult:
         """Run the LLM on the given prompts.
@@ -710,8 +691,8 @@ class BaseLLM(BaseLanguageModel[str], ABC):
     def _stream(
         self,
         prompt: str,
-        stop: Optional[list[str]] = None,
-        run_manager: Optional[CallbackManagerForLLMRun] = None,
+        stop: list[str] | None = None,
+        run_manager: CallbackManagerForLLMRun | None = None,
         **kwargs: Any,
     ) -> Iterator[GenerationChunk]:
         """Stream the LLM on the given prompt.
@@ -738,8 +719,8 @@ class BaseLLM(BaseLanguageModel[str], ABC):
     async def _astream(
         self,
         prompt: str,
-        stop: Optional[list[str]] = None,
-        run_manager: Optional[AsyncCallbackManagerForLLMRun] = None,
+        stop: list[str] | None = None,
+        run_manager: AsyncCallbackManagerForLLMRun | None = None,
         **kwargs: Any,
     ) -> AsyncIterator[GenerationChunk]:
         """An async version of the _stream method.
@@ -783,8 +764,8 @@ class BaseLLM(BaseLanguageModel[str], ABC):
     def generate_prompt(
         self,
         prompts: list[PromptValue],
-        stop: Optional[list[str]] = None,
-        callbacks: Optional[Union[Callbacks, list[Callbacks]]] = None,
+        stop: list[str] | None = None,
+        callbacks: Callbacks | list[Callbacks] | None = None,
         **kwargs: Any,
     ) -> LLMResult:
         prompt_strings = [p.to_string() for p in prompts]
@@ -794,8 +775,8 @@ class BaseLLM(BaseLanguageModel[str], ABC):
     async def agenerate_prompt(
         self,
         prompts: list[PromptValue],
-        stop: Optional[list[str]] = None,
-        callbacks: Optional[Union[Callbacks, list[Callbacks]]] = None,
+        stop: list[str] | None = None,
+        callbacks: Callbacks | list[Callbacks] | None = None,
         **kwargs: Any,
     ) -> LLMResult:
         prompt_strings = [p.to_string() for p in prompts]
@@ -806,7 +787,7 @@ class BaseLLM(BaseLanguageModel[str], ABC):
     def _generate_helper(
         self,
         prompts: list[str],
-        stop: Optional[list[str]],
+        stop: list[str] | None,
         run_managers: list[CallbackManagerForLLMRun],
         *,
         new_arg_supported: bool,
@@ -829,7 +810,9 @@ class BaseLLM(BaseLanguageModel[str], ABC):
                 run_manager.on_llm_error(e, response=LLMResult(generations=[]))
             raise
         flattened_outputs = output.flatten()
-        for manager, flattened_output in zip(run_managers, flattened_outputs):
+        for manager, flattened_output in zip(
+            run_managers, flattened_outputs, strict=False
+        ):
             manager.on_llm_end(flattened_output)
         if run_managers:
             output.run = [
@@ -840,13 +823,13 @@ class BaseLLM(BaseLanguageModel[str], ABC):
     def generate(
         self,
         prompts: list[str],
-        stop: Optional[list[str]] = None,
-        callbacks: Optional[Union[Callbacks, list[Callbacks]]] = None,
+        stop: list[str] | None = None,
+        callbacks: Callbacks | list[Callbacks] | None = None,
         *,
-        tags: Optional[Union[list[str], list[list[str]]]] = None,
-        metadata: Optional[Union[dict[str, Any], list[dict[str, Any]]]] = None,
-        run_name: Optional[Union[str, list[str]]] = None,
-        run_id: Optional[Union[uuid.UUID, list[Optional[uuid.UUID]]]] = None,
+        tags: list[str] | list[list[str]] | None = None,
+        metadata: dict[str, Any] | list[dict[str, Any]] | None = None,
+        run_name: str | list[str] | None = None,
+        run_id: uuid.UUID | list[uuid.UUID | None] | None = None,
         **kwargs: Any,
     ) -> LLMResult:
         """Pass a sequence of prompts to a model and return generations.
@@ -859,13 +842,13 @@ class BaseLLM(BaseLanguageModel[str], ABC):
         1. Take advantage of batched calls,
         2. Need more output from the model than just the top generated value,
         3. Are building chains that are agnostic to the underlying language model
-           type (e.g., pure text completion models vs chat models).
+            type (e.g., pure text completion models vs chat models).
 
         Args:
             prompts: List of string prompts.
             stop: Stop words to use when generating. Model output is cut off at the
                 first occurrence of any of these substrings.
-            callbacks: Callbacks to pass through. Used for executing additional
+            callbacks: `Callbacks` to pass through. Used for executing additional
                 functionality, such as logging or streaming, throughout generation.
             tags: List of tags to associate with each prompt. If provided, the length
                 of the list must match the length of the prompts list.
@@ -881,12 +864,12 @@ class BaseLLM(BaseLanguageModel[str], ABC):
 
         Raises:
             ValueError: If prompts is not a list.
-            ValueError: If the length of ``callbacks``, ``tags``, ``metadata``, or
-                ``run_name`` (if provided) does not match the length of prompts.
+            ValueError: If the length of `callbacks`, `tags`, `metadata`, or
+                `run_name` (if provided) does not match the length of prompts.
 
         Returns:
-            An LLMResult, which contains a list of candidate Generations for each input
-                prompt and additional model provider-specific output.
+            An `LLMResult`, which contains a list of candidate `Generations` for each
+                input prompt and additional model provider-specific output.
         """
         if not isinstance(prompts, list):
             msg = (
@@ -936,14 +919,12 @@ class BaseLLM(BaseLanguageModel[str], ABC):
                 msg = "run_name must be a list of the same length as prompts"
                 raise ValueError(msg)
             callbacks = cast("list[Callbacks]", callbacks)
-            tags_list = cast(
-                "list[Optional[list[str]]]", tags or ([None] * len(prompts))
-            )
+            tags_list = cast("list[list[str] | None]", tags or ([None] * len(prompts)))
             metadata_list = cast(
-                "list[Optional[dict[str, Any]]]", metadata or ([{}] * len(prompts))
+                "list[dict[str, Any] | None]", metadata or ([{}] * len(prompts))
             )
             run_name_list = run_name or cast(
-                "list[Optional[str]]", ([None] * len(prompts))
+                "list[str | None]", ([None] * len(prompts))
             )
             callback_managers = [
                 CallbackManager.configure(
@@ -955,7 +936,9 @@ class BaseLLM(BaseLanguageModel[str], ABC):
                     meta,
                     self.metadata,
                 )
-                for callback, tag, meta in zip(callbacks, tags_list, metadata_list)
+                for callback, tag, meta in zip(
+                    callbacks, tags_list, metadata_list, strict=False
+                )
             ]
         else:
             # We've received a single callbacks arg to apply to all inputs
@@ -970,7 +953,7 @@ class BaseLLM(BaseLanguageModel[str], ABC):
                     self.metadata,
                 )
             ] * len(prompts)
-            run_name_list = [cast("Optional[str]", run_name)] * len(prompts)
+            run_name_list = [cast("str | None", run_name)] * len(prompts)
         run_ids_list = self._get_run_ids_list(run_id, prompts)
         params = self.dict()
         params["stop"] = stop
@@ -996,7 +979,11 @@ class BaseLLM(BaseLanguageModel[str], ABC):
                     run_id=run_id_,
                 )[0]
                 for callback_manager, prompt, run_name, run_id_ in zip(
-                    callback_managers, prompts, run_name_list, run_ids_list
+                    callback_managers,
+                    prompts,
+                    run_name_list,
+                    run_ids_list,
+                    strict=False,
                 )
             ]
             return self._generate_helper(
@@ -1046,7 +1033,7 @@ class BaseLLM(BaseLanguageModel[str], ABC):
 
     @staticmethod
     def _get_run_ids_list(
-        run_id: Optional[Union[uuid.UUID, list[Optional[uuid.UUID]]]], prompts: list
+        run_id: uuid.UUID | list[uuid.UUID | None] | None, prompts: list
     ) -> list:
         if run_id is None:
             return [None] * len(prompts)
@@ -1063,7 +1050,7 @@ class BaseLLM(BaseLanguageModel[str], ABC):
     async def _agenerate_helper(
         self,
         prompts: list[str],
-        stop: Optional[list[str]],
+        stop: list[str] | None,
         run_managers: list[AsyncCallbackManagerForLLMRun],
         *,
         new_arg_supported: bool,
@@ -1093,7 +1080,7 @@ class BaseLLM(BaseLanguageModel[str], ABC):
             *[
                 run_manager.on_llm_end(flattened_output)
                 for run_manager, flattened_output in zip(
-                    run_managers, flattened_outputs
+                    run_managers, flattened_outputs, strict=False
                 )
             ]
         )
@@ -1106,13 +1093,13 @@ class BaseLLM(BaseLanguageModel[str], ABC):
     async def agenerate(
         self,
         prompts: list[str],
-        stop: Optional[list[str]] = None,
-        callbacks: Optional[Union[Callbacks, list[Callbacks]]] = None,
+        stop: list[str] | None = None,
+        callbacks: Callbacks | list[Callbacks] | None = None,
         *,
-        tags: Optional[Union[list[str], list[list[str]]]] = None,
-        metadata: Optional[Union[dict[str, Any], list[dict[str, Any]]]] = None,
-        run_name: Optional[Union[str, list[str]]] = None,
-        run_id: Optional[Union[uuid.UUID, list[Optional[uuid.UUID]]]] = None,
+        tags: list[str] | list[list[str]] | None = None,
+        metadata: dict[str, Any] | list[dict[str, Any]] | None = None,
+        run_name: str | list[str] | None = None,
+        run_id: uuid.UUID | list[uuid.UUID | None] | None = None,
         **kwargs: Any,
     ) -> LLMResult:
         """Asynchronously pass a sequence of prompts to a model and return generations.
@@ -1125,13 +1112,13 @@ class BaseLLM(BaseLanguageModel[str], ABC):
         1. Take advantage of batched calls,
         2. Need more output from the model than just the top generated value,
         3. Are building chains that are agnostic to the underlying language model
-           type (e.g., pure text completion models vs chat models).
+            type (e.g., pure text completion models vs chat models).
 
         Args:
             prompts: List of string prompts.
             stop: Stop words to use when generating. Model output is cut off at the
                 first occurrence of any of these substrings.
-            callbacks: Callbacks to pass through. Used for executing additional
+            callbacks: `Callbacks` to pass through. Used for executing additional
                 functionality, such as logging or streaming, throughout generation.
             tags: List of tags to associate with each prompt. If provided, the length
                 of the list must match the length of the prompts list.
@@ -1146,12 +1133,12 @@ class BaseLLM(BaseLanguageModel[str], ABC):
                 to the model provider API call.
 
         Raises:
-            ValueError: If the length of ``callbacks``, ``tags``, ``metadata``, or
-                ``run_name`` (if provided) does not match the length of prompts.
+            ValueError: If the length of `callbacks`, `tags`, `metadata`, or
+                `run_name` (if provided) does not match the length of prompts.
 
         Returns:
-            An LLMResult, which contains a list of candidate Generations for each input
-                prompt and additional model provider-specific output.
+            An `LLMResult`, which contains a list of candidate `Generations` for each
+                input prompt and additional model provider-specific output.
         """
         if isinstance(metadata, list):
             metadata = [
@@ -1191,14 +1178,12 @@ class BaseLLM(BaseLanguageModel[str], ABC):
                 msg = "run_name must be a list of the same length as prompts"
                 raise ValueError(msg)
             callbacks = cast("list[Callbacks]", callbacks)
-            tags_list = cast(
-                "list[Optional[list[str]]]", tags or ([None] * len(prompts))
-            )
+            tags_list = cast("list[list[str] | None]", tags or ([None] * len(prompts)))
             metadata_list = cast(
-                "list[Optional[dict[str, Any]]]", metadata or ([{}] * len(prompts))
+                "list[dict[str, Any] | None]", metadata or ([{}] * len(prompts))
             )
             run_name_list = run_name or cast(
-                "list[Optional[str]]", ([None] * len(prompts))
+                "list[str | None]", ([None] * len(prompts))
             )
             callback_managers = [
                 AsyncCallbackManager.configure(
@@ -1210,7 +1195,9 @@ class BaseLLM(BaseLanguageModel[str], ABC):
                     meta,
                     self.metadata,
                 )
-                for callback, tag, meta in zip(callbacks, tags_list, metadata_list)
+                for callback, tag, meta in zip(
+                    callbacks, tags_list, metadata_list, strict=False
+                )
             ]
         else:
             # We've received a single callbacks arg to apply to all inputs
@@ -1225,7 +1212,7 @@ class BaseLLM(BaseLanguageModel[str], ABC):
                     self.metadata,
                 )
             ] * len(prompts)
-            run_name_list = [cast("Optional[str]", run_name)] * len(prompts)
+            run_name_list = [cast("str | None", run_name)] * len(prompts)
         run_ids_list = self._get_run_ids_list(run_id, prompts)
         params = self.dict()
         params["stop"] = stop
@@ -1255,7 +1242,11 @@ class BaseLLM(BaseLanguageModel[str], ABC):
                         run_id=run_id_,
                     )
                     for callback_manager, prompt, run_name, run_id_ in zip(
-                        callback_managers, prompts, run_name_list, run_ids_list
+                        callback_managers,
+                        prompts,
+                        run_name_list,
+                        run_ids_list,
+                        strict=False,
                     )
                 ]
             )
@@ -1308,64 +1299,14 @@ class BaseLLM(BaseLanguageModel[str], ABC):
         generations = [existing_prompts[i] for i in range(len(prompts))]
         return LLMResult(generations=generations, llm_output=llm_output, run=run_info)
 
-    @deprecated("0.1.7", alternative="invoke", removal="1.0")
-    def __call__(
-        self,
-        prompt: str,
-        stop: Optional[list[str]] = None,
-        callbacks: Callbacks = None,
-        *,
-        tags: Optional[list[str]] = None,
-        metadata: Optional[dict[str, Any]] = None,
-        **kwargs: Any,
-    ) -> str:
-        """Check Cache and run the LLM on the given prompt and input.
-
-        Args:
-            prompt: The prompt to generate from.
-            stop: Stop words to use when generating. Model output is cut off at the
-                first occurrence of any of these substrings.
-            callbacks: Callbacks to pass through. Used for executing additional
-                functionality, such as logging or streaming, throughout generation.
-            tags: List of tags to associate with the prompt.
-            metadata: Metadata to associate with the prompt.
-            **kwargs: Arbitrary additional keyword arguments. These are usually passed
-                to the model provider API call.
-
-        Returns:
-            The generated text.
-
-        Raises:
-            ValueError: If the prompt is not a string.
-        """
-        if not isinstance(prompt, str):
-            msg = (
-                "Argument `prompt` is expected to be a string. Instead found "
-                f"{type(prompt)}. If you want to run the LLM on multiple prompts, use "
-                "`generate` instead."
-            )
-            raise ValueError(msg)  # noqa: TRY004
-        return (
-            self.generate(
-                [prompt],
-                stop=stop,
-                callbacks=callbacks,
-                tags=tags,
-                metadata=metadata,
-                **kwargs,
-            )
-            .generations[0][0]
-            .text
-        )
-
     async def _call_async(
         self,
         prompt: str,
-        stop: Optional[list[str]] = None,
+        stop: list[str] | None = None,
         callbacks: Callbacks = None,
         *,
-        tags: Optional[list[str]] = None,
-        metadata: Optional[dict[str, Any]] = None,
+        tags: list[str] | None = None,
+        metadata: dict[str, Any] | None = None,
         **kwargs: Any,
     ) -> str:
         """Check Cache and run the LLM on the given prompt and input."""
@@ -1379,50 +1320,6 @@ class BaseLLM(BaseLanguageModel[str], ABC):
         )
         return result.generations[0][0].text
 
-    @deprecated("0.1.7", alternative="invoke", removal="1.0")
-    @override
-    def predict(
-        self, text: str, *, stop: Optional[Sequence[str]] = None, **kwargs: Any
-    ) -> str:
-        stop_ = None if stop is None else list(stop)
-        return self(text, stop=stop_, **kwargs)
-
-    @deprecated("0.1.7", alternative="invoke", removal="1.0")
-    @override
-    def predict_messages(
-        self,
-        messages: list[BaseMessage],
-        *,
-        stop: Optional[Sequence[str]] = None,
-        **kwargs: Any,
-    ) -> BaseMessage:
-        text = get_buffer_string(messages)
-        stop_ = None if stop is None else list(stop)
-        content = self(text, stop=stop_, **kwargs)
-        return AIMessage(content=content)
-
-    @deprecated("0.1.7", alternative="ainvoke", removal="1.0")
-    @override
-    async def apredict(
-        self, text: str, *, stop: Optional[Sequence[str]] = None, **kwargs: Any
-    ) -> str:
-        stop_ = None if stop is None else list(stop)
-        return await self._call_async(text, stop=stop_, **kwargs)
-
-    @deprecated("0.1.7", alternative="ainvoke", removal="1.0")
-    @override
-    async def apredict_messages(
-        self,
-        messages: list[BaseMessage],
-        *,
-        stop: Optional[Sequence[str]] = None,
-        **kwargs: Any,
-    ) -> BaseMessage:
-        text = get_buffer_string(messages)
-        stop_ = None if stop is None else list(stop)
-        content = await self._call_async(text, stop=stop_, **kwargs)
-        return AIMessage(content=content)
-
     def __str__(self) -> str:
         """Return a string representation of the object for printing."""
         cls_name = f"\033[1m{self.__class__.__name__}\033[0m"
@@ -1440,7 +1337,7 @@ class BaseLLM(BaseLanguageModel[str], ABC):
         starter_dict["_type"] = self._llm_type
         return starter_dict
 
-    def save(self, file_path: Union[Path, str]) -> None:
+    def save(self, file_path: Path | str) -> None:
         """Save the LLM.
 
         Args:
@@ -1450,11 +1347,9 @@ class BaseLLM(BaseLanguageModel[str], ABC):
             ValueError: If the file path is not a string or Path object.
 
         Example:
-
-            .. code-block:: python
-
-                llm.save(file_path="path/llm.yaml")
-
+            ```python
+            llm.save(file_path="path/llm.yaml")
+            ```
         """
         # Convert file to Path object.
         save_path = Path(file_path)
@@ -1499,19 +1394,14 @@ 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
     def _call(
         self,
         prompt: str,
-        stop: Optional[list[str]] = None,
-        run_manager: Optional[CallbackManagerForLLMRun] = None,
+        stop: list[str] | None = None,
+        run_manager: CallbackManagerForLLMRun | None = None,
         **kwargs: Any,
     ) -> str:
         """Run the LLM on the given input.
@@ -1534,8 +1424,8 @@ class LLM(BaseLLM):
     async def _acall(
         self,
         prompt: str,
-        stop: Optional[list[str]] = None,
-        run_manager: Optional[AsyncCallbackManagerForLLMRun] = None,
+        stop: list[str] | None = None,
+        run_manager: AsyncCallbackManagerForLLMRun | None = None,
         **kwargs: Any,
     ) -> str:
         """Async version of the _call method.
@@ -1568,8 +1458,8 @@ class LLM(BaseLLM):
     def _generate(
         self,
         prompts: list[str],
-        stop: Optional[list[str]] = None,
-        run_manager: Optional[CallbackManagerForLLMRun] = None,
+        stop: list[str] | None = None,
+        run_manager: CallbackManagerForLLMRun | None = None,
         **kwargs: Any,
     ) -> LLMResult:
         # TODO: add caching here.
@@ -1587,8 +1477,8 @@ class LLM(BaseLLM):
     async def _agenerate(
         self,
         prompts: list[str],
-        stop: Optional[list[str]] = None,
-        run_manager: Optional[AsyncCallbackManagerForLLMRun] = None,
+        stop: list[str] | None = None,
+        run_manager: AsyncCallbackManagerForLLMRun | None = None,
         **kwargs: Any,
     ) -> LLMResult:
         generations = []