langchain-core 0.4.0.dev0__py3-none-any.whl → 1.0.0a2__py3-none-any.whl

langchain_core/tracers/event_stream.py

@@ -38,7 +38,6 @@ from langchain_core.runnables.utils import (
 from langchain_core.tracers._streaming import _StreamingCallbackHandler
 from langchain_core.tracers.memory_stream import _MemoryStream
 from langchain_core.utils.aiter import aclosing, py_anext
-from langchain_core.v1.messages import MessageV1
 
 if TYPE_CHECKING:
     from collections.abc import AsyncIterator, Iterator, Sequence
@@ -46,8 +45,6 @@ if TYPE_CHECKING:
     from langchain_core.documents import Document
     from langchain_core.runnables import Runnable, RunnableConfig
     from langchain_core.tracers.log_stream import LogEntry
-    from langchain_core.v1.messages import AIMessage as AIMessageV1
-    from langchain_core.v1.messages import AIMessageChunk as AIMessageChunkV1
 
 logger = logging.getLogger(__name__)
 
@@ -300,7 +297,7 @@ class _AstreamEventsCallbackHandler(AsyncCallbackHandler, _StreamingCallbackHand
     async def on_chat_model_start(
         self,
         serialized: dict[str, Any],
-        messages: Union[list[list[BaseMessage]], list[MessageV1]],
+        messages: list[list[BaseMessage]],
         *,
         run_id: UUID,
         tags: Optional[list[str]] = None,
@@ -310,8 +307,6 @@ class _AstreamEventsCallbackHandler(AsyncCallbackHandler, _StreamingCallbackHand
         **kwargs: Any,
     ) -> None:
         """Start a trace for an LLM run."""
-        # below cast is because type is converted in handle_event
-        messages = cast("list[list[BaseMessage]]", messages)
         name_ = _assign_name(name, serialized)
         run_type = "chat_model"
 
@@ -412,18 +407,13 @@ class _AstreamEventsCallbackHandler(AsyncCallbackHandler, _StreamingCallbackHand
         self,
         token: str,
         *,
-        chunk: Optional[
-            Union[GenerationChunk, ChatGenerationChunk, AIMessageChunkV1]
-        ] = None,
+        chunk: Optional[Union[GenerationChunk, ChatGenerationChunk]] = None,
         run_id: UUID,
         parent_run_id: Optional[UUID] = None,
         **kwargs: Any,
     ) -> None:
         """Run on new LLM token. Only available when streaming is enabled."""
         run_info = self.run_map.get(run_id)
-        chunk = cast(
-            "Optional[Union[GenerationChunk, ChatGenerationChunk]]", chunk
-        )  # converted in handle_event
         chunk_: Union[GenerationChunk, BaseMessageChunk]
 
         if run_info is None:
@@ -466,10 +456,9 @@ class _AstreamEventsCallbackHandler(AsyncCallbackHandler, _StreamingCallbackHand
 
     @override
     async def on_llm_end(
-        self, response: Union[LLMResult, AIMessageV1], *, run_id: UUID, **kwargs: Any
+        self, response: LLMResult, *, run_id: UUID, **kwargs: Any
     ) -> None:
         """End a trace for an LLM run."""
-        response = cast("LLMResult", response)  # converted in handle_event
         run_info = self.run_map.pop(run_id)
         inputs_ = run_info["inputs"]
 
@@ -1010,7 +999,7 @@ async def _astream_events_implementation_v2(
                 continue
 
             # If it's the end event corresponding to the root runnable
-            # we dont include the input in the event since it's guaranteed
+            # we don't include the input in the event since it's guaranteed
             # to be included in the first event.
             if (
                 event["run_id"] == first_event_run_id

langchain_core/tracers/langchain.py

@@ -5,7 +5,7 @@ from __future__ import annotations
 import logging
 from concurrent.futures import ThreadPoolExecutor
 from datetime import datetime, timezone
-from typing import TYPE_CHECKING, Any, Optional, Union, cast
+from typing import TYPE_CHECKING, Any, Optional, Union
 from uuid import UUID
 
 from langsmith import Client
@@ -21,15 +21,12 @@ from typing_extensions import override
 
 from langchain_core.env import get_runtime_environment
 from langchain_core.load import dumpd
-from langchain_core.messages.utils import convert_from_v1_message
 from langchain_core.tracers.base import BaseTracer
 from langchain_core.tracers.schemas import Run
-from langchain_core.v1.messages import MessageV1Types
 
 if TYPE_CHECKING:
     from langchain_core.messages import BaseMessage
     from langchain_core.outputs import ChatGenerationChunk, GenerationChunk
-    from langchain_core.v1.messages import AIMessageChunk, MessageV1
 
 logger = logging.getLogger(__name__)
 _LOGGED = set()
@@ -116,7 +113,7 @@ class LangChainTracer(BaseTracer):
     def on_chat_model_start(
         self,
         serialized: dict[str, Any],
-        messages: Union[list[list[BaseMessage]], list[MessageV1]],
+        messages: list[list[BaseMessage]],
         *,
         run_id: UUID,
         tags: Optional[list[str]] = None,
@@ -143,12 +140,6 @@ class LangChainTracer(BaseTracer):
         start_time = datetime.now(timezone.utc)
         if metadata:
             kwargs.update({"metadata": metadata})
-        if isinstance(messages[0], MessageV1Types):
-            # Convert from v1 messages to BaseMessage
-            messages = [
-                [convert_from_v1_message(msg) for msg in messages]  # type: ignore[arg-type]
-            ]
-        messages = cast("list[list[BaseMessage]]", messages)
         chat_model_run = Run(
             id=run_id,
             parent_run_id=parent_run_id,
@@ -241,9 +232,7 @@ class LangChainTracer(BaseTracer):
         self,
         token: str,
         run_id: UUID,
-        chunk: Optional[
-            Union[GenerationChunk, ChatGenerationChunk, AIMessageChunk]
-        ] = None,
+        chunk: Optional[Union[GenerationChunk, ChatGenerationChunk]] = None,
         parent_run_id: Optional[UUID] = None,
     ) -> Run:
         """Append token event to LLM run and return the run."""

langchain_core/tracers/log_stream.py

@@ -34,7 +34,6 @@ if TYPE_CHECKING:
 
     from langchain_core.runnables.utils import Input, Output
     from langchain_core.tracers.schemas import Run
-    from langchain_core.v1.messages import AIMessageChunk
 
 
 class LogEntry(TypedDict):
@@ -177,7 +176,7 @@ class RunLog(RunLogPatch):
         # Then compare that the ops are the same
         return super().__eq__(other)
 
-    __hash__ = None  # type: ignore[assignment]
+    __hash__ = None
 
 
 T = TypeVar("T")
@@ -486,7 +485,7 @@ class LogStreamCallbackHandler(BaseTracer, _StreamingCallbackHandler):
         self,
         run: Run,
         token: str,
-        chunk: Optional[Union[GenerationChunk, ChatGenerationChunk, AIMessageChunk]],
+        chunk: Optional[Union[GenerationChunk, ChatGenerationChunk]],
     ) -> None:
         """Process new LLM token."""
         index = self._key_map_by_run_id.get(run.id)

langchain_core/utils/_merge.py

@@ -57,6 +57,11 @@ def merge_dicts(left: dict[str, Any], *others: dict[str, Any]) -> dict[str, Any]
                 #             "should either occur once or have the same value across "
                 #             "all dicts."
                 #         )
+                if (right_k == "index" and merged[right_k].startswith("lc_")) or (
+                    right_k in ("id", "output_version", "model_provider")
+                    and merged[right_k] == right_v
+                ):
+                    continue
                 merged[right_k] += right_v
             elif isinstance(merged[right_k], dict):
                 merged[right_k] = merge_dicts(merged[right_k], right_v)
@@ -93,20 +98,53 @@ def merge_lists(left: Optional[list], *others: Optional[list]) -> Optional[list]
             merged = other.copy()
         else:
             for e in other:
-                if isinstance(e, dict) and "index" in e and isinstance(e["index"], int):
+                if (
+                    isinstance(e, dict)
+                    and "index" in e
+                    and (
+                        isinstance(e["index"], int)
+                        or (
+                            isinstance(e["index"], str) and e["index"].startswith("lc_")
+                        )
+                    )
+                ):
                     to_merge = [
                         i
                         for i, e_left in enumerate(merged)
-                        if e_left["index"] == e["index"]
+                        if "index" in e_left and e_left["index"] == e["index"]
                     ]
                     if to_merge:
                         # TODO: Remove this once merge_dict is updated with special
                         # handling for 'type'.
-                        new_e = (
-                            {k: v for k, v in e.items() if k != "type"}
-                            if "type" in e
-                            else e
-                        )
+                        if (left_type := merged[to_merge[0]].get("type")) and (
+                            e.get("type") == "non_standard" and "value" in e
+                        ):
+                            if left_type != "non_standard":
+                                # standard + non_standard
+                                new_e: dict[str, Any] = {
+                                    "extras": {
+                                        k: v
+                                        for k, v in e["value"].items()
+                                        if k != "type"
+                                    }
+                                }
+                            else:
+                                # non_standard + non_standard
+                                new_e = {
+                                    "value": {
+                                        k: v
+                                        for k, v in e["value"].items()
+                                        if k != "type"
+                                    }
+                                }
+                                if "index" in e:
+                                    new_e["index"] = e["index"]
+                        else:
+                            new_e = (
+                                {k: v for k, v in e.items() if k != "type"}
+                                if "type" in e
+                                else e
+                            )
                         merged[to_merge[0]] = merge_dicts(merged[to_merge[0]], new_e)
                     else:
                         merged.append(e)

langchain_core/utils/function_calling.py

@@ -277,7 +277,7 @@ def _convert_any_typed_dicts_to_pydantic(
         )
         fields: dict = {}
         for arg, arg_type in annotations_.items():
-            if get_origin(arg_type) is Annotated:
+            if get_origin(arg_type) is Annotated:  # type: ignore[comparison-overlap]
                 annotated_args = get_args(arg_type)
                 new_arg_type = _convert_any_typed_dicts_to_pydantic(
                     annotated_args[0], depth=depth + 1, visited=visited
@@ -575,12 +575,23 @@ def convert_to_openai_tool(
 
         Added support for OpenAI's image generation built-in tool.
     """
+    from langchain_core.tools import Tool
+
     if isinstance(tool, dict):
         if tool.get("type") in _WellKnownOpenAITools:
             return tool
         # As of 03.12.25 can be "web_search_preview" or "web_search_preview_2025_03_11"
         if (tool.get("type") or "").startswith("web_search_preview"):
             return tool
+    if isinstance(tool, Tool) and (tool.metadata or {}).get("type") == "custom_tool":
+        oai_tool = {
+            "type": "custom",
+            "name": tool.name,
+            "description": tool.description,
+        }
+        if tool.metadata is not None and "format" in tool.metadata:
+            oai_tool["format"] = tool.metadata["format"]
+        return oai_tool
     oai_function = convert_to_openai_function(tool, strict=strict)
     return {"type": "function", "function": oai_function}
 
@@ -629,15 +640,16 @@ def tool_example_to_messages(
 
     The list of messages per example by default corresponds to:
 
-    1) HumanMessage: contains the content from which content should be extracted.
-    2) AIMessage: contains the extracted information from the model
-    3) ToolMessage: contains confirmation to the model that the model requested a tool
-       correctly.
+    1. ``HumanMessage``: contains the content from which content should be extracted.
+    2. ``AIMessage``: contains the extracted information from the model
+    3. ``ToolMessage``: contains confirmation to the model that the model requested a
+       tool correctly.
 
-    If `ai_response` is specified, there will be a final AIMessage with that response.
+    If ``ai_response`` is specified, there will be a final ``AIMessage`` with that
+    response.
 
-    The ToolMessage is required because some chat models are hyper-optimized for agents
-    rather than for an extraction use case.
+    The ``ToolMessage`` is required because some chat models are hyper-optimized for
+    agents rather than for an extraction use case.
 
     Arguments:
         input: string, the user input
@@ -646,7 +658,7 @@ def tool_example_to_messages(
         tool_outputs: Optional[list[str]], a list of tool call outputs.
             Does not need to be provided. If not provided, a placeholder value
             will be inserted. Defaults to None.
-        ai_response: Optional[str], if provided, content for a final AIMessage.
+        ai_response: Optional[str], if provided, content for a final ``AIMessage``.
 
     Returns:
         A list of messages
@@ -728,6 +740,7 @@ def _parse_google_docstring(
     """Parse the function and argument descriptions from the docstring of a function.
 
     Assumes the function docstring follows Google Python style guide.
+
     """
     if docstring:
         docstring_blocks = docstring.split("\n\n")

langchain_core/utils/utils.py

@@ -9,6 +9,7 @@ import warnings
 from collections.abc import Iterator, Sequence
 from importlib.metadata import version
 from typing import Any, Callable, Optional, Union, overload
+from uuid import uuid4
 
 from packaging.version import parse
 from pydantic import SecretStr
@@ -466,3 +467,31 @@ def secret_from_env(
         raise ValueError(msg)
 
     return get_secret_from_env
+
+
+LC_AUTO_PREFIX = "lc_"
+"""LangChain auto-generated ID prefix for messages and content blocks."""
+
+LC_ID_PREFIX = "lc_run-"
+"""Internal tracing/callback system identifier.
+
+Used for:
+- Tracing. Every LangChain operation (LLM call, chain execution, tool use, etc.)
+  gets a unique run_id (UUID)
+- Enables tracking parent-child relationships between operations
+"""
+
+
+def ensure_id(id_val: Optional[str]) -> str:
+    """Ensure the ID is a valid string, generating a new UUID if not provided.
+
+    Auto-generated UUIDs are prefixed by ``'lc_'`` to indicate they are
+    LangChain-generated IDs.
+
+    Args:
+        id_val: Optional string ID value to validate.
+
+    Returns:
+        A string ID, either the validated provided value or a newly generated UUID4.
+    """
+    return id_val or str(f"{LC_AUTO_PREFIX}{uuid4()}")

langchain_core/version.py

@@ -1,3 +1,3 @@
 """langchain-core version information and utilities."""
 
-VERSION = "0.4.0.dev0"
+VERSION = "1.0.0a2"

{langchain_core-0.4.0.dev0.dist-info → langchain_core-1.0.0a2.dist-info}/METADATA

@@ -1,12 +1,12 @@
 Metadata-Version: 2.1
 Name: langchain-core
-Version: 0.4.0.dev0
+Version: 1.0.0a2
 Summary: Building applications with LLMs through composability
 License: MIT
 Project-URL: Source Code, https://github.com/langchain-ai/langchain/tree/master/libs/core
 Project-URL: Release Notes, https://github.com/langchain-ai/langchain/releases?q=tag%3A%22langchain-core%3D%3D0%22&expanded=true
 Project-URL: repository, https://github.com/langchain-ai/langchain
-Requires-Python: >=3.9
+Requires-Python: >=3.10
 Requires-Dist: langsmith>=0.3.45
 Requires-Dist: tenacity!=8.4.0,<10.0.0,>=8.1.0
 Requires-Dist: jsonpatch<2.0,>=1.33
@@ -39,13 +39,13 @@ For full documentation see the [API reference](https://python.langchain.com/api_
 
 ## 1️⃣ Core Interface: Runnables
 
-The concept of a Runnable is central to LangChain Core – it is the interface that most LangChain Core components implement, giving them
+The concept of a `Runnable` is central to LangChain Core – it is the interface that most LangChain Core components implement, giving them
 
-- a common invocation interface (invoke, batch, stream, etc.)
+- a common invocation interface (`invoke()`, `batch()`, `stream()`, etc.)
 - built-in utilities for retries, fallbacks, schemas and runtime configurability
-- easy deployment with [LangServe](https://github.com/langchain-ai/langserve)
+- easy deployment with [LangGraph](https://github.com/langchain-ai/langgraph)
 
-For more check out the [runnable docs](https://python.langchain.com/docs/expression_language/interface). Examples of components that implement the interface include: LLMs, Chat Models, Prompts, Retrievers, Tools, Output Parsers.
+For more check out the [runnable docs](https://python.langchain.com/docs/concepts/runnables/). Examples of components that implement the interface include: LLMs, Chat Models, Prompts, Retrievers, Tools, Output Parsers.
 
 You can use LangChain Core objects in two ways:
 
@@ -69,7 +69,7 @@ LangChain Expression Language (LCEL) is a _declarative language_ for composing L
 
 LangChain Core compiles LCEL sequences to an _optimized execution plan_, with automatic parallelization, streaming, tracing, and async support.
 
-For more check out the [LCEL docs](https://python.langchain.com/docs/expression_language/).
+For more check out the [LCEL docs](https://python.langchain.com/docs/concepts/lcel/).
 
 ![Diagram outlining the hierarchical organization of the LangChain framework, displaying the interconnected parts across multiple layers.](https://raw.githubusercontent.com/langchain-ai/langchain/master/docs/static/svg/langchain_stack_112024.svg "LangChain Framework Overview")
 
@@ -77,8 +77,6 @@ For more advanced use cases, also check out [LangGraph](https://github.com/langc
 
 ## 📕 Releases & Versioning
 
-`langchain-core` is currently on version `0.1.x`.
-
 As `langchain-core` contains the base abstractions and runtime for the whole LangChain ecosystem, we will communicate any breaking changes with advance notice and version bumps. The exception for this is anything in `langchain_core.beta`. The reason for `langchain_core.beta` is that given the rate of change of the field, being able to move quickly is still a priority, and this module is our attempt to do so.
 
 Minor version increases will occur for: