langchain-core 1.6.13

Source: https://github.com/langchain-ai/langchain
Artifact scanned: langchain_core-1.6.13-py3-none-any.whl (wheel · 561.2 KB · SHA-256 8605de6f84a4…)
Compared with: langchain_core-1.6.12-py3-none-any.whl (0 signals introduced since)
Files: 182 scanned, 5 skipped (binary, oversized, or unrecognised)
Signals: 0 critical · 0 warn · 19 info
Scan time: 10.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.3.0
Scanned (UTC): 2026-10-23 09:24

Signals

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

info ~~warn~~ → info by review dynamic-attribute 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 names into globals().
Reasoning
This is the standard lazy-import __getattr__ pattern: import_attr resolves a name from a module-level mapping and caches it in globals(). Benign, no obfuscation of payload.
info ~~warn~~ → info by review frame-introspection 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.93 Uses inspect.currentframe to inspect the call stack in an internal API helper.
Reasoning
inspect.currentframe() used to detect whether the caller is in a particular context, wrapped in AttributeError handling for implementations lacking frame support. Common, legitimate introspection in a library API helper.
info ~~warn~~ → info by review dynamic-attribute 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 caching imports into globals() in the callbacks package.
Reasoning
Same standard lazy-import __getattr__ pattern for langchain callbacks package; resolves a known submodule attribute and caches it.
info ~~warn~~ → info by review dynamic-attribute 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 caching imports into globals() in document_loaders.
Reasoning
Standard lazy-import __getattr__ pattern; benign module plumbing.
info ~~warn~~ → info by review dynamic-attribute 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 caching imports into globals() in documents package.
Reasoning
Standard lazy-import __getattr__ pattern; benign module plumbing.
info ~~warn~~ → info by review dynamic-attribute 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 caching imports into globals() in embeddings package.
Reasoning
Standard lazy-import __getattr__ pattern; benign module plumbing.
info ~~warn~~ → info by review dynamic-attribute 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 caching imports into globals() in example_selectors package.
Reasoning
Standard lazy-import __getattr__ pattern; benign module plumbing.
info ~~warn~~ → info by review dynamic-attribute 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 caching imports into globals() in indexing package.
Reasoning
Standard lazy-import __getattr__ pattern; benign module plumbing.
info ~~warn~~ → info by review dynamic-attribute 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 caching imports into globals() in language_models package.
Reasoning
Standard lazy-import __getattr__ pattern; benign module plumbing.
info ~~warn~~ → info by review dynamic-attribute 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 caching imports into globals() in load package.
Reasoning
Standard lazy-import __getattr__ pattern; benign module plumbing.
info ~~warn~~ → info by review dynamic-attribute 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 caching imports into globals() in messages package.
Reasoning
Standard lazy-import __getattr__ pattern; benign module plumbing.
info ~~warn~~ → info by review dynamic-attribute 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 caching imports into globals() in output_parsers package.
Reasoning
Standard lazy-import __getattr__ pattern; benign module plumbing.
info ~~warn~~ → info by review dynamic-attribute 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 caching imports into globals() in outputs package.
Reasoning
Standard lazy-import __getattr__ pattern; benign module plumbing.
info ~~warn~~ → info by review dynamic-attribute 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 caching imports into globals() in prompts package.
Reasoning
Standard lazy-import __getattr__ pattern; benign module plumbing.
info ~~warn~~ → info by review dynamic-attribute 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 caching imports into globals() in runnables package.
Reasoning
Standard lazy-import __getattr__ pattern; benign module plumbing.
info ~~warn~~ → info by review dynamic-attribute 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 caching imports into globals() in tools package.
Reasoning
Standard lazy-import __getattr__ pattern; benign module plumbing.
info ~~warn~~ → info by review dynamic-attribute 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 caching imports into globals() in tracers package.
Reasoning
Standard lazy-import __getattr__ pattern; benign module plumbing.
info ~~warn~~ → info by review dynamic-attribute 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-level __getattr__ that lazily imports a langchain_core submodule attribute and caches it in globals().
Reasoning
This is the standard lazy-import pattern in __getattr__: an attribute is resolved via import_attr against the package's own spec parent, then cached into globals() so later lookups skip __getattr__. The name comes from the module's own lazy-import mapping, not from untrusted input, and no decoding, process spawning, or network access is involved.
info ~~warn~~ → info by review dynamic-attribute 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 Module-level __getattr__ lazily importing vectorstore attributes and caching them in globals().
Reasoning
Same lazy-loading idiom as the utils package: import_attr resolves a known attribute from the package's own submodules and the result is cached in globals(). The flagged dynamic globals write is an ordinary performance and import-deferral technique in this context.

Reproduce This Scan

Run disclude locally to verify. These commands scan the published file; the "new in this release" marks come from comparing it with the previous release's file, which they don't repeat. 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.3.0
curl -fsSL -o langchain_core-1.6.13-py3-none-any.whl https://files.pythonhosted.org/packages/b0/2f/c15b026e7b4aa093bc237c909bf909e8a59143b1315efee43c296fad58ce/langchain_core-1.6.13-py3-none-any.whl
printf '%s  %s\n' 8605de6f84a49902ef6be03d6fe2a126e7dfc35184315989689f341181f0a8fb langchain_core-1.6.13-py3-none-any.whl | shasum -a 256 -c -
unzip -q langchain_core-1.6.13-py3-none-any.whl -d pkg
disclude scan --untrusted --severity info pkg