langchain-core 1.6.12

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

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.95 Lazy module attribute loader that caches imported attributes in globals().
Reasoning
This is the standard lazy-loading __getattr__ pattern: it imports a named attribute from a module in the package and caches it in globals. The import target comes from a fixed mapping of the package's own modules, not from untrusted input.
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 Uses inspect.currentframe to inspect the call stack for internal-use checks.
Reasoning
inspect.currentframe() is used to detect whether code is running within a particular call context, a common and legitimate use in API deprecation helpers. It has no network, exec, or dropper behavior.
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.95 Lazy attribute loader for the callbacks package.
Reasoning
Same standard lazy-import __getattr__ pattern from langchain_core's package __init__, resolving names against the package's own submodules.
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.95 Lazy attribute loader for the document_loaders package.
Reasoning
Standard lazy-import __getattr__ pattern resolving names within the package itself; the globals write is a cache, not a hidden payload.
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.95 Lazy attribute loader for the documents package.
Reasoning
Standard lazy-import __getattr__ pattern resolving package-internal names and caching them in globals.
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.95 Lazy attribute loader for the embeddings package.
Reasoning
Standard lazy-import __getattr__ pattern for package-internal names; no external or encoded input is involved.
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.95 Lazy attribute loader for the example_selectors package.
Reasoning
Standard lazy-import __getattr__ pattern for package-internal names with a globals cache.
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.95 Lazy attribute loader for the indexing package.
Reasoning
Standard lazy-import __getattr__ pattern for package-internal names with a globals cache.
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.95 Lazy attribute loader for the language_models package.
Reasoning
Standard lazy-import __getattr__ pattern for package-internal names with a globals cache.
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.95 Lazy attribute loader for the load package.
Reasoning
Standard lazy-import __getattr__ pattern for package-internal names with a globals cache.
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.95 Lazy attribute loader for the messages package.
Reasoning
Standard lazy-import __getattr__ pattern for package-internal names with a globals cache.
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.95 Lazy attribute loader for the output_parsers package.
Reasoning
Standard lazy-import __getattr__ pattern for package-internal names with a globals cache.
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.95 Lazy attribute loader for the outputs package.
Reasoning
Standard lazy-import __getattr__ pattern for package-internal names with a globals cache.
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.95 Lazy attribute loader for the prompts package.
Reasoning
Standard lazy-import __getattr__ pattern for package-internal names with a globals cache.
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 Lazy attribute loader for the runnables package.
Reasoning
Standard lazy-import __getattr__ pattern for package-internal names with a globals cache.
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 for the tools package.
Reasoning
Standard lazy-import __getattr__ pattern for package-internal names with a globals cache.
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 attribute loader for the tracers package.
Reasoning
Standard lazy-import __getattr__ pattern for package-internal names with a globals cache.
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 A module-level __getattr__ that lazily imports an attribute and caches it in globals() for langchain_core utils.
Reasoning
This is the standard lazy-import idiom: a module-level __getattr__ imports the named attribute via a helper, caches it in globals(), and returns it. The pattern is legitimate and common in large Python packages like langchain_core. No network, shell, or decoding behavior is present in the snippet.
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 A lazy-import __getattr__ in the vectorstores package that caches resolved attributes in globals().
Reasoning
Same lazy-loading pattern as the utils module: import_attr resolves a name relative to the package and the result is cached in globals(). This is ordinary package lazy-import code with no malicious indicators in the snippet.

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.1.0
git clone https://github.com/langchain-ai/langchain langchain && cd langchain
git checkout langchain-core==1.6.12
disclude scan --severity info --diff langchain-core==1.6.11 libs/core