langchain-core 1.0.0rc3__py3-none-any.whl → 1.0.2__py3-none-any.whl

langchain_core/tools/base.py

@@ -483,7 +483,7 @@ class ChildTool(BaseTool):
     """The tool response format.
 
     If `"content"` then the output of the tool is interpreted as the contents of a
-    ToolMessage. If `"content_and_artifact"` then the output is expected to be a
+    `ToolMessage`. If `"content_and_artifact"` then the output is expected to be a
     two-tuple corresponding to the (content, artifact) of a `ToolMessage`.
     """
 
@@ -615,7 +615,7 @@ class ChildTool(BaseTool):
             The parsed and validated input.
 
         Raises:
-            ValueError: If string input is provided with JSON schema `args_schema`.
+            ValueError: If `string` input is provided with JSON schema `args_schema`.
             ValueError: If InjectedToolCallId is required but `tool_call_id` is not
                 provided.
             TypeError: If args_schema is not a Pydantic `BaseModel` or dict.
@@ -707,6 +707,35 @@ class ChildTool(BaseTool):
             kwargs["run_manager"] = kwargs["run_manager"].get_sync()
         return await run_in_executor(None, self._run, *args, **kwargs)
 
+    def _filter_injected_args(self, tool_input: dict) -> dict:
+        """Filter out injected tool arguments from the input dictionary.
+
+        Injected arguments are those annotated with InjectedToolArg or its
+        subclasses, or arguments in FILTERED_ARGS like run_manager and callbacks.
+
+        Args:
+            tool_input: The tool input dictionary to filter.
+
+        Returns:
+            A filtered dictionary with injected arguments removed.
+        """
+        # Start with filtered args from the constant
+        filtered_keys = set[str](FILTERED_ARGS)
+
+        # If we have an args_schema, use it to identify injected args
+        if self.args_schema is not None:
+            try:
+                annotations = get_all_basemodel_annotations(self.args_schema)
+                for field_name, field_type in annotations.items():
+                    if _is_injected_arg_type(field_type):
+                        filtered_keys.add(field_name)
+            except Exception:  # noqa: S110
+                # If we can't get annotations, just use FILTERED_ARGS
+                pass
+
+        # Filter out the injected keys from tool_input
+        return {k: v for k, v in tool_input.items() if k not in filtered_keys}
+
     def _to_args_and_kwargs(
         self, tool_input: str | dict, tool_call_id: str | None
     ) -> tuple[tuple, dict]:
@@ -794,17 +823,29 @@ class ChildTool(BaseTool):
             self.metadata,
         )
 
+        # Filter out injected arguments from callback inputs
+        filtered_tool_input = (
+            self._filter_injected_args(tool_input)
+            if isinstance(tool_input, dict)
+            else None
+        )
+
+        # Use filtered inputs for the input_str parameter as well
+        tool_input_str = (
+            tool_input
+            if isinstance(tool_input, str)
+            else str(
+                filtered_tool_input if filtered_tool_input is not None else tool_input
+            )
+        )
+
         run_manager = callback_manager.on_tool_start(
             {"name": self.name, "description": self.description},
-            tool_input if isinstance(tool_input, str) else str(tool_input),
+            tool_input_str,
             color=start_color,
             name=run_name,
             run_id=run_id,
-            # Inputs by definition should always be dicts.
-            # For now, it's unclear whether this assumption is ever violated,
-            # but if it is we will send a `None` value to the callback instead
-            # TODO: will need to address issue via a patch.
-            inputs=tool_input if isinstance(tool_input, dict) else None,
+            inputs=filtered_tool_input,
             **kwargs,
         )
 
@@ -905,17 +946,30 @@ class ChildTool(BaseTool):
             metadata,
             self.metadata,
         )
+
+        # Filter out injected arguments from callback inputs
+        filtered_tool_input = (
+            self._filter_injected_args(tool_input)
+            if isinstance(tool_input, dict)
+            else None
+        )
+
+        # Use filtered inputs for the input_str parameter as well
+        tool_input_str = (
+            tool_input
+            if isinstance(tool_input, str)
+            else str(
+                filtered_tool_input if filtered_tool_input is not None else tool_input
+            )
+        )
+
         run_manager = await callback_manager.on_tool_start(
             {"name": self.name, "description": self.description},
-            tool_input if isinstance(tool_input, str) else str(tool_input),
+            tool_input_str,
             color=start_color,
             name=run_name,
             run_id=run_id,
-            # Inputs by definition should always be dicts.
-            # For now, it's unclear whether this assumption is ever violated,
-            # but if it is we will send a `None` value to the callback instead
-            # TODO: will need to address issue via a patch.
-            inputs=tool_input if isinstance(tool_input, dict) else None,
+            inputs=filtered_tool_input,
             **kwargs,
         )
         content = None

langchain_core/tools/convert.py

@@ -89,6 +89,7 @@ def tool(
         runnable: Optional runnable to convert to a tool. Must be provided as a
             positional argument.
         description: Optional description for the tool.
+
             Precedence for the tool description value is as follows:
 
             - `description` argument
@@ -105,11 +106,13 @@ def tool(
         infer_schema: Whether to infer the schema of the arguments from
             the function's signature. This also makes the resultant tool
             accept a dictionary input to its `run()` function.
-        response_format: The tool response format. If `"content"` then the output of
-            the tool is interpreted as the contents of a `ToolMessage`. If
-            `"content_and_artifact"` then the output is expected to be a two-tuple
-            corresponding to the `(content, artifact)` of a `ToolMessage`.
-        parse_docstring: if `infer_schema` and `parse_docstring`, will attempt to
+        response_format: The tool response format.
+
+            If `"content"` then the output of the tool is interpreted as the contents of
+            a `ToolMessage`. If `"content_and_artifact"` then the output is expected to
+            be a two-tuple corresponding to the `(content, artifact)` of a
+            `ToolMessage`.
+        parse_docstring: If `infer_schema` and `parse_docstring`, will attempt to
             parse parameter descriptions from Google Style function docstrings.
         error_on_invalid_docstring: if `parse_docstring` is provided, configure
             whether to raise `ValueError` on invalid Google Style docstrings.
@@ -151,8 +154,6 @@ def tool(
             return "partial json of results", {"full": "object of results"}
         ```
 
-    !!! version-added "Added in version 0.2.14"
-
         Parse Google-style docstrings:
 
         ```python

langchain_core/tools/retriever.py

@@ -83,11 +83,12 @@ def create_retriever_tool(
             model, so should be descriptive.
         document_prompt: The prompt to use for the document.
         document_separator: The separator to use between documents.
-        response_format: The tool response format. If `"content"` then the output of
-            the tool is interpreted as the contents of a `ToolMessage`. If
-            `"content_and_artifact"` then the output is expected to be a two-tuple
-            corresponding to the `(content, artifact)` of a `ToolMessage` (artifact
-            being a list of documents in this case).
+        response_format: The tool response format.
+
+            If `"content"` then the output of the tool is interpreted as the contents of
+            a `ToolMessage`. If `"content_and_artifact"` then the output is expected to
+            be a two-tuple corresponding to the `(content, artifact)` of a `ToolMessage`
+            (artifact being a list of documents in this case).
 
     Returns:
         Tool class to pass to an agent.

langchain_core/tools/structured.py

@@ -151,11 +151,13 @@ class StructuredTool(BaseTool):
             return_direct: Whether to return the result directly or as a callback.
             args_schema: The schema of the tool's input arguments.
             infer_schema: Whether to infer the schema from the function's signature.
-            response_format: The tool response format. If `"content"` then the output of
-                the tool is interpreted as the contents of a `ToolMessage`. If
-                `"content_and_artifact"` then the output is expected to be a two-tuple
-                corresponding to the `(content, artifact)` of a `ToolMessage`.
-            parse_docstring: if `infer_schema` and `parse_docstring`, will attempt
+            response_format: The tool response format.
+
+                If `"content"` then the output of the tool is interpreted as the
+                contents of a `ToolMessage`. If `"content_and_artifact"` then the output
+                is expected to be a two-tuple corresponding to the `(content, artifact)`
+                of a `ToolMessage`.
+            parse_docstring: If `infer_schema` and `parse_docstring`, will attempt
                 to parse parameter descriptions from Google Style function docstrings.
             error_on_invalid_docstring: if `parse_docstring` is provided, configure
                 whether to raise `ValueError` on invalid Google Style docstrings.

langchain_core/tracers/event_stream.py

@@ -128,7 +128,10 @@ class _AstreamEventsCallbackHandler(AsyncCallbackHandler, _StreamingCallbackHand
             exclude_tags=exclude_tags,
         )
 
-        loop = asyncio.get_event_loop()
+        try:
+            loop = asyncio.get_event_loop()
+        except RuntimeError:
+            loop = asyncio.new_event_loop()
         memory_stream = _MemoryStream[StreamEvent](loop)
         self.send_stream = memory_stream.get_send_stream()
         self.receive_stream = memory_stream.get_receive_stream()

langchain_core/tracers/log_stream.py

@@ -96,10 +96,10 @@ class RunLogPatch:
     """Patch to the run log."""
 
     ops: list[dict[str, Any]]
-    """List of jsonpatch operations, which describe how to create the run state
+    """List of JSONPatch operations, which describe how to create the run state
     from an empty dict. This is the minimal representation of the log, designed to
     be serialized as JSON and sent over the wire to reconstruct the log on the other
-    side. Reconstruction of the state can be done with any jsonpatch-compliant library,
+    side. Reconstruction of the state can be done with any JSONPatch-compliant library,
     see https://jsonpatch.com for more information."""
 
     def __init__(self, *ops: dict[str, Any]) -> None:
@@ -264,7 +264,10 @@ class LogStreamCallbackHandler(BaseTracer, _StreamingCallbackHandler):
         self.exclude_types = exclude_types
         self.exclude_tags = exclude_tags
 
-        loop = asyncio.get_event_loop()
+        try:
+            loop = asyncio.get_event_loop()
+        except RuntimeError:
+            loop = asyncio.new_event_loop()
         memory_stream = _MemoryStream[RunLogPatch](loop)
         self.lock = threading.Lock()
         self.send_stream = memory_stream.get_send_stream()

langchain_core/utils/function_calling.py

@@ -425,6 +425,14 @@ def convert_to_openai_function(
             oai_function["parameters"] = _recursive_set_additional_properties_false(
                 oai_function["parameters"]
             )
+            # All fields must be `required`
+            parameters = oai_function.get("parameters")
+            if isinstance(parameters, dict):
+                fields = parameters.get("properties")
+                if isinstance(fields, dict) and fields:
+                    parameters = dict(parameters)
+                    parameters["required"] = list(fields.keys())
+                    oai_function["parameters"] = parameters
     return oai_function
 
 

langchain_core/utils/json_schema.py

@@ -226,7 +226,7 @@ def dereference_refs(
         ... }
         >>> result = dereference_refs(schema)  # Won't cause infinite recursion
 
-    Note:
+    !!! note
         - Circular references are handled gracefully by breaking cycles
         - Mixed $ref objects (with both $ref and other properties) are supported
         - Additional properties in mixed $refs override resolved properties

langchain_core/utils/strings.py

@@ -30,10 +30,7 @@ def stringify_dict(data: dict) -> str:
     Returns:
         The stringified dictionary.
     """
-    text = ""
-    for key, value in data.items():
-        text += key + ": " + stringify_value(value) + "\n"
-    return text
+    return "".join(f"{key}: {stringify_value(value)}\n" for key, value in data.items())
 
 
 def comma_list(items: list[Any]) -> str:

langchain_core/utils/utils.py

@@ -218,7 +218,7 @@ def _build_model_kwargs(
     values: dict[str, Any],
     all_required_field_names: set[str],
 ) -> dict[str, Any]:
-    """Build "model_kwargs" param from Pydantic constructor values.
+    """Build `model_kwargs` param from Pydantic constructor values.
 
     Args:
         values: All init args passed in by user.
@@ -228,8 +228,8 @@ def _build_model_kwargs(
         Extra kwargs.
 
     Raises:
-        ValueError: If a field is specified in both values and extra_kwargs.
-        ValueError: If a field is specified in model_kwargs.
+        ValueError: If a field is specified in both `values` and `extra_kwargs`.
+        ValueError: If a field is specified in `model_kwargs`.
     """
     extra_kwargs = values.get("model_kwargs", {})
     for field_name in list(values):
@@ -267,6 +267,10 @@ def build_extra_kwargs(
 ) -> dict[str, Any]:
     """Build extra kwargs from values and extra_kwargs.
 
+    !!! danger "DON'T USE"
+        Kept for backwards-compatibility but should never have been public. Use the
+        internal `_build_model_kwargs` function instead.
+
     Args:
         extra_kwargs: Extra kwargs passed in by user.
         values: Values passed in by user.
@@ -276,9 +280,10 @@ def build_extra_kwargs(
         Extra kwargs.
 
     Raises:
-        ValueError: If a field is specified in both values and extra_kwargs.
-        ValueError: If a field is specified in model_kwargs.
+        ValueError: If a field is specified in both `values` and `extra_kwargs`.
+        ValueError: If a field is specified in `model_kwargs`.
     """
+    # DON'T USE! Kept for backwards-compatibility but should never have been public.
     for field_name in list(values):
         if field_name in extra_kwargs:
             msg = f"Found {field_name} supplied twice."
@@ -292,6 +297,7 @@ def build_extra_kwargs(
             )
             extra_kwargs[field_name] = values.pop(field_name)
 
+    # DON'T USE! Kept for backwards-compatibility but should never have been public.
     invalid_model_kwargs = all_required_field_names.intersection(extra_kwargs.keys())
     if invalid_model_kwargs:
         msg = (
@@ -300,6 +306,7 @@ def build_extra_kwargs(
         )
         raise ValueError(msg)
 
+    # DON'T USE! Kept for backwards-compatibility but should never have been public.
     return extra_kwargs