langchain-core 1.6.13

Source: https://github.com/langchain-ai/langchain
Tag scanned: langchain-core==1.6.13
Directory: libs/core (only this part of the repository was scanned)
Compared with: langchain-core==1.6.12 (0 signals introduced since)
Files: 372 scanned, 27 skipped (binary, oversized, or unrecognised)
Signals: 0 critical · 0 warn · 19 info
Scan time: 14.3 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 11:29

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.93 Lazy attribute loader that caches imported symbols in the module globals.
Reasoning
The snippet is the standard PEP 562 lazy-loading pattern: a module-level __getattr__ imports the requested attribute with import_attr and caches it in globals(). The name comes from a fixed lookup of the package's own public API, not from untrusted input, and this is a well-known library idiom.
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 Call-stack introspection to determine whether a caller is internal to the library.
Reasoning
inspect.currentframe() is used in a try/except AttributeError to check the caller's module for internal-use deprecation handling. It only reads the call stack for diagnostics and does not execute or exfiltrate anything.
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.93 Lazy attribute loader for the callbacks package.
Reasoning
Same standard lazy-import __getattr__ pattern as the other langchain_core package __init__ files, resolving a known public symbol and caching it. No untrusted input or dangerous operation is involved.
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.93 Lazy attribute loader for the document_loaders package.
Reasoning
Standard PEP 562 lazy-import __getattr__ for the document_loaders package. It resolves the library's own public symbols by name and caches them, which is routine.
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.93 Lazy attribute loader for the documents package.
Reasoning
Standard lazy-import __getattr__ in the documents package, resolving its own public names. The pattern is benign and matches the rest of the 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.93 Lazy attribute loader for the embeddings package.
Reasoning
Standard lazy-import __getattr__ for the embeddings package, using fixed module-internal names. No dynamic execution of untrusted data occurs.
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.93 Lazy attribute loader for the example_selectors package.
Reasoning
Standard lazy-import __getattr__ for the example_selectors package. It resolves known public symbols and caches them, with no security-relevant behavior.
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.93 Lazy attribute loader for the indexing package.
Reasoning
Standard PEP 562 lazy-import __getattr__ in the indexing package, matching the common langchain_core pattern for deferred imports.
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.93 Lazy attribute loader for the language_models package.
Reasoning
Standard lazy-import __getattr__ for the language_models package, resolving the library's own symbols. The globals() write is the usual caching step.
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.93 Lazy attribute loader for the load package.
Reasoning
Standard lazy-import __getattr__ in the load package. Although the load area handles serialization, this snippet only resolves fixed attribute names through import_attr and does not deserialize or execute untrusted data.
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.93 Lazy attribute loader for the messages package.
Reasoning
Standard PEP 562 lazy-import __getattr__ for the messages package, using the library's own public names. This is routine.
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.93 Lazy attribute loader for the output_parsers package.
Reasoning
Standard lazy-import __getattr__ for the output_parsers package. It resolves known symbols and caches the result, with no dynamic execution of external input.
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.93 Lazy attribute loader for the outputs package.
Reasoning
Standard lazy-import __getattr__ in the outputs package, matching the same benign library-wide pattern.
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.93 Lazy attribute loader for the prompts package.
Reasoning
Standard lazy-import __getattr__ for the prompts package, resolving its own public symbols. The snippet shows no template execution or other risky behavior.
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.93 Lazy attribute loader for the runnables package.
Reasoning
Standard lazy-import __getattr__ in the runnables package, resolving known names and caching them in globals.
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.93 Lazy attribute loader for the tools package.
Reasoning
Standard lazy-import __getattr__ for the tools package. The names come from a fixed internal mapping, not from untrusted input, so there is no evasion.
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.93 Lazy attribute loader for the tracers package.
Reasoning
Standard lazy-import __getattr__ in the tracers package, the same benign deferred-import pattern used across langchain_core.
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.93 Module-level __getattr__ that lazily imports a named attribute from the package and caches it in globals().
Reasoning
This is the standard lazy-import idiom in __getattr__: it resolves a module attribute by name via import_attr with the package's own __spec__.parent, caches the result in globals(), and returns it. The pattern is legitimate and widely used in langchain packages; nothing here executes fetched data or obscures intent.
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.93 Module-level __getattr__ that lazily imports vectorstore attributes by name and caches them in globals().
Reasoning
Same lazy-loading __getattr__ pattern as the utils package: import_attr resolves a name within the package's own modules, and the result is cached in globals(). It is a common, benign way to defer heavy imports and matches the rest of the library's structure.

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.13
disclude scan --severity info --diff langchain-core==1.6.12 libs/core