langchain-core 1.6.10

Source: https://github.com/langchain-ai/langchain
Tag scanned: langchain-core==1.6.10
Directory: libs/core (only this part of the repository was scanned)
Compared with: langchain-core==1.6.9 (0 signals introduced since)
Files: 371 scanned, 27 skipped (binary, oversized, or unrecognised)
Signals: 0 critical · 0 warn · 19 info
Scan time: 11.2 s
LLM review: Reviewed by claude-haiku-5-5 (Anthropic): 19 of 19 warn and critical signals; 19 demoted to info.
Disclude version: 4.0.0
Scanned (UTC): 2026-10-14 18:54

Signals

Ordered by severity, then signals introduced in this release. Hidden characters are shown as ⟨U+…⟩.

info ~~warn~~ → info by review dynamic-attribute libs/core/langchain_core/_api/__init__.py:77:5

reach-by-name through `globals` (ast pass, confidence 0.60)
```
    result = import_attr(attr_name, module_name, __spec__.parent)
    globals()[attr_name] = result
    return result
```
likely benign LLM, confidence 0.97 Lazy attribute loader in a package __init__ that caches imported attributes in globals().
Reasoning
This is the standard lazy-import __getattr__ pattern: it imports an attribute from a sibling module named by the caller and caches it in globals. It is a legitimate module-level optimization in a well-known library, not obfuscation.
info ~~warn~~ → info by review frame-introspection libs/core/langchain_core/_api/internal.py:8:17

`inspect.currentframe` — call-stack frame introspection (ast pass, confidence 0.70)
```
    try:
        frame = inspect.currentframe()
    except AttributeError:
        return False
```
likely benign LLM, confidence 0.90 Checks for frame support via inspect.currentframe inside a guarded try block.
Reasoning
inspect.currentframe() wrapped in a try/except AttributeError is a common way to detect whether code runs in a Python implementation that supports frame introspection. It is used for benign runtime checks, not for hiding behaviour.
info ~~warn~~ → info by review dynamic-attribute libs/core/langchain_core/callbacks/__init__.py:127:5

reach-by-name through `globals` (ast pass, confidence 0.60)
```
    result = import_attr(attr_name, module_name, __spec__.parent)
    globals()[attr_name] = result
    return result
```
likely benign LLM, confidence 0.97 Lazy attribute loader in the callbacks package __init__.
Reasoning
Same standard lazy-import __getattr__ idiom as the other package __init__ files, importing a sibling module attribute by name from a fixed package. Benign.
info ~~warn~~ → info by review dynamic-attribute libs/core/langchain_core/document_loaders/__init__.py:34:5

reach-by-name through `globals` (ast pass, confidence 0.60)
```
    result = import_attr(attr_name, module_name, __spec__.parent)
    globals()[attr_name] = result
    return result
```
likely benign LLM, confidence 0.97 Lazy attribute loader in the document_loaders package __init__.
Reasoning
Standard lazy-import __getattr__ pattern for a package's public API. The import target is a fixed sibling module, so there is no injection or obfuscation.
info ~~warn~~ → info by review dynamic-attribute libs/core/langchain_core/documents/__init__.py:50:5

reach-by-name through `globals` (ast pass, confidence 0.60)
```
    result = import_attr(attr_name, module_name, __spec__.parent)
    globals()[attr_name] = result
    return result
```
likely benign LLM, confidence 0.97 Lazy attribute loader in the documents package __init__.
Reasoning
Standard lazy-import idiom caching attributes in globals. The flagged pattern is a normal lazy-loading mechanism for this package.
info ~~warn~~ → info by review dynamic-attribute libs/core/langchain_core/embeddings/__init__.py:26:5

reach-by-name through `globals` (ast pass, confidence 0.60)
```
    result = import_attr(attr_name, module_name, __spec__.parent)
    globals()[attr_name] = result
    return result
```
likely benign LLM, confidence 0.97 Lazy attribute loader in the embeddings package __init__.
Reasoning
Standard lazy-import __getattr__ pattern with a fixed sibling module. No sign of malicious intent.
info ~~warn~~ → info by review dynamic-attribute libs/core/langchain_core/example_selectors/__init__.py:42:5

reach-by-name through `globals` (ast pass, confidence 0.60)
```
    result = import_attr(attr_name, module_name, __spec__.parent)
    globals()[attr_name] = result
    return result
```
likely benign LLM, confidence 0.97 Lazy attribute loader in the example_selectors package __init__.
Reasoning
Standard lazy-import idiom for a package's public attributes, with no dynamic or attacker-controlled input.
info ~~warn~~ → info by review dynamic-attribute libs/core/langchain_core/indexing/__init__.py:48:5

reach-by-name through `globals` (ast pass, confidence 0.60)
```
    result = import_attr(attr_name, module_name, __spec__.parent)
    globals()[attr_name] = result
    return result
```
likely benign LLM, confidence 0.97 Lazy attribute loader in the indexing package __init__.
Reasoning
Standard lazy-import __getattr__ pattern reaching sibling module attributes. Benign.
info ~~warn~~ → info by review dynamic-attribute libs/core/langchain_core/language_models/__init__.py:111:5

reach-by-name through `globals` (ast pass, confidence 0.60)
```
    result = import_attr(attr_name, module_name, __spec__.parent)
    globals()[attr_name] = result
    return result
```
likely benign LLM, confidence 0.97 Lazy attribute loader in the language_models package __init__.
Reasoning
Standard lazy-import idiom with a fixed module reference, matching the other langchain_core package initializers.
info ~~warn~~ → info by review dynamic-attribute libs/core/langchain_core/load/__init__.py:39:5

reach-by-name through `globals` (ast pass, confidence 0.60)
```
    result = import_attr(attr_name, module_name, __spec__.parent)
    globals()[attr_name] = result
    return result
```
likely benign LLM, confidence 0.97 Lazy attribute loader in the load package __init__.
Reasoning
Standard lazy-import __getattr__ pattern. The load package handles serialization, but this code only resolves names to fixed sibling modules, so it is benign here.
info ~~warn~~ → info by review dynamic-attribute libs/core/langchain_core/messages/__init__.py:193:5

reach-by-name through `globals` (ast pass, confidence 0.60)
```
    result = import_attr(attr_name, module_name, __spec__.parent)
    globals()[attr_name] = result
    return result
```
likely benign LLM, confidence 0.97 Lazy attribute loader in the messages package __init__.
Reasoning
Standard lazy-import idiom reaching fixed sibling modules, with no dynamic code execution or attacker-controlled names.
info ~~warn~~ → info by review dynamic-attribute libs/core/langchain_core/output_parsers/__init__.py:96:5

reach-by-name through `globals` (ast pass, confidence 0.60)
```
    result = import_attr(attr_name, module_name, __spec__.parent)
    globals()[attr_name] = result
    return result
```
likely benign LLM, confidence 0.97 Lazy attribute loader in the output_parsers package __init__.
Reasoning
Standard lazy-import __getattr__ pattern for a package's public API. Benign.
info ~~warn~~ → info by review dynamic-attribute libs/core/langchain_core/outputs/__init__.py:61:5

reach-by-name through `globals` (ast pass, confidence 0.60)
```
    result = import_attr(attr_name, module_name, __spec__.parent)
    globals()[attr_name] = result
    return result
```
likely benign LLM, confidence 0.97 Lazy attribute loader in the outputs package __init__.
Reasoning
Standard lazy-import idiom caching sibling module attributes in globals. Benign.
info ~~warn~~ → info by review dynamic-attribute libs/core/langchain_core/prompts/__init__.py:96:5

reach-by-name through `globals` (ast pass, confidence 0.60)
```
    result = import_attr(attr_name, module_name, __spec__.parent)
    globals()[attr_name] = result
    return result
```
likely benign LLM, confidence 0.97 Lazy attribute loader in the prompts package __init__.
Reasoning
Standard lazy-import __getattr__ pattern with a fixed sibling module reference. Benign.
info ~~warn~~ → info by review dynamic-attribute libs/core/langchain_core/runnables/__init__.py:131:5

reach-by-name through `globals` (ast pass, confidence 0.60)
```
    result = import_attr(attr_name, module_name, __spec__.parent)
    globals()[attr_name] = result
    return result
```
likely benign LLM, confidence 0.95 Module-level __getattr__ that lazily imports a package submodule attribute and caches it in globals().
Reasoning
This is the standard PEP 562 lazy-loading pattern in __getattr__: it imports a named attribute from a known sibling module of the same package and caches it in globals. The attr_name comes from the module's own lazy-import mapping, not from untrusted input, so there is no malicious reach-by-name.
info ~~warn~~ → info by review dynamic-attribute libs/core/langchain_core/tools/__init__.py:90:5

reach-by-name through `globals` (ast pass, confidence 0.60)
```
    result = import_attr(attr_name, module_name, __spec__.parent)
    globals()[attr_name] = result
    return result
```
likely benign LLM, confidence 0.95 Lazy attribute loader in the tools package __init__ that imports and caches a named export.
Reasoning
Same legitimate PEP 562 lazy-import idiom from langchain_core: resolves a whitelisted attribute name from the package's own submodule and memoizes it in globals. Not obfuscation or an attack vector.
info ~~warn~~ → info by review dynamic-attribute libs/core/langchain_core/tracers/__init__.py:45:5

reach-by-name through `globals` (ast pass, confidence 0.60)
```
    result = import_attr(attr_name, module_name, __spec__.parent)
    globals()[attr_name] = result
    return result
```
likely benign LLM, confidence 0.95 Lazy-loading __getattr__ in the tracers package that imports and caches re-exported attributes.
Reasoning
Standard lazy-loading __getattr__ pattern using globals() caching for package re-exports. The dynamic lookup is bounded to the package's own declared exports, so this is a common legitimate idiom.
info ~~warn~~ → info by review dynamic-attribute libs/core/langchain_core/utils/__init__.py:106:5

reach-by-name through `globals` (ast pass, confidence 0.60)
```
    result = import_attr(attr_name, module_name, __spec__.parent)
    globals()[attr_name] = result
    return result
```
likely benign LLM, confidence 0.95 Module __getattr__ that lazily imports utility attributes and stores them in globals.
Reasoning
Conventional PEP 562 lazy import in a utils package __init__. The name is resolved against the package's own import map, which is a routine way to reduce import-time cost, not a sign of malicious dynamic execution.
info ~~warn~~ → info by review dynamic-attribute libs/core/langchain_core/vectorstores/__init__.py:43:5

reach-by-name through `globals` (ast pass, confidence 0.60)
```
    result = import_attr(attr_name, module_name, __spec__.parent)
    globals()[attr_name] = result
    return result
```
likely benign LLM, confidence 0.95 Lazy __getattr__ in the vectorstores package __init__ that imports and caches submodule exports.
Reasoning
Identical lazy-loading idiom for re-exporting vectorstore symbols from the package's own submodules. Benign, widely used pattern in large Python libraries.

Reproduce This Scan

Run disclude locally to verify. Add --format sarif for SARIF output. Add --llm (with an API key in the environment) to include the LLM review.

cargo install disclude --version 4.0.0
git clone https://github.com/langchain-ai/langchain langchain && cd langchain
git checkout langchain-core==1.6.10
disclude scan --severity info --diff langchain-core==1.6.9 libs/core