sentienceapi 0.90.16__py3-none-any.whl → 0.98.0__py3-none-any.whl

sentience/extension/release.json

@@ -1,45 +1,45 @@
 {
-  "url": "https://api.github.com/repos/SentienceAPI/Sentience-Geometry-Chrome-Extension/releases/273122615",
-  "assets_url": "https://api.github.com/repos/SentienceAPI/Sentience-Geometry-Chrome-Extension/releases/273122615/assets",
-  "upload_url": "https://uploads.github.com/repos/SentienceAPI/Sentience-Geometry-Chrome-Extension/releases/273122615/assets{?name,label}",
-  "html_url": "https://github.com/SentienceAPI/Sentience-Geometry-Chrome-Extension/releases/tag/v2.0.7",
-  "id": 273122615,
+  "url": "https://api.github.com/repos/SentienceAPI/Sentience-Geometry-Chrome-Extension/releases/277802850",
+  "assets_url": "https://api.github.com/repos/SentienceAPI/Sentience-Geometry-Chrome-Extension/releases/277802850/assets",
+  "upload_url": "https://uploads.github.com/repos/SentienceAPI/Sentience-Geometry-Chrome-Extension/releases/277802850/assets{?name,label}",
+  "html_url": "https://github.com/SentienceAPI/Sentience-Geometry-Chrome-Extension/releases/tag/v2.7.0",
+  "id": 277802850,
   "author": {
-    "login": "github-actions[bot]",
-    "id": 41898282,
-    "node_id": "MDM6Qm90NDE4OTgyODI=",
-    "avatar_url": "https://avatars.githubusercontent.com/in/15368?v=4",
+    "login": "rcholic",
+    "id": 135060,
+    "node_id": "MDQ6VXNlcjEzNTA2MA==",
+    "avatar_url": "https://avatars.githubusercontent.com/u/135060?v=4",
     "gravatar_id": "",
-    "url": "https://api.github.com/users/github-actions%5Bbot%5D",
-    "html_url": "https://github.com/apps/github-actions",
-    "followers_url": "https://api.github.com/users/github-actions%5Bbot%5D/followers",
-    "following_url": "https://api.github.com/users/github-actions%5Bbot%5D/following{/other_user}",
-    "gists_url": "https://api.github.com/users/github-actions%5Bbot%5D/gists{/gist_id}",
-    "starred_url": "https://api.github.com/users/github-actions%5Bbot%5D/starred{/owner}{/repo}",
-    "subscriptions_url": "https://api.github.com/users/github-actions%5Bbot%5D/subscriptions",
-    "organizations_url": "https://api.github.com/users/github-actions%5Bbot%5D/orgs",
-    "repos_url": "https://api.github.com/users/github-actions%5Bbot%5D/repos",
-    "events_url": "https://api.github.com/users/github-actions%5Bbot%5D/events{/privacy}",
-    "received_events_url": "https://api.github.com/users/github-actions%5Bbot%5D/received_events",
-    "type": "Bot",
+    "url": "https://api.github.com/users/rcholic",
+    "html_url": "https://github.com/rcholic",
+    "followers_url": "https://api.github.com/users/rcholic/followers",
+    "following_url": "https://api.github.com/users/rcholic/following{/other_user}",
+    "gists_url": "https://api.github.com/users/rcholic/gists{/gist_id}",
+    "starred_url": "https://api.github.com/users/rcholic/starred{/owner}{/repo}",
+    "subscriptions_url": "https://api.github.com/users/rcholic/subscriptions",
+    "organizations_url": "https://api.github.com/users/rcholic/orgs",
+    "repos_url": "https://api.github.com/users/rcholic/repos",
+    "events_url": "https://api.github.com/users/rcholic/events{/privacy}",
+    "received_events_url": "https://api.github.com/users/rcholic/received_events",
+    "type": "User",
     "user_view_type": "public",
     "site_admin": false
   },
-  "node_id": "RE_kwDOQshiJ84QR4U3",
-  "tag_name": "v2.0.7",
+  "node_id": "RE_kwDOQshiJ84Qju9i",
+  "tag_name": "v2.7.0",
   "target_commitish": "main",
-  "name": "Release v2.0.7",
+  "name": "Release v2.7.0",
   "draft": false,
   "immutable": false,
   "prerelease": false,
-  "created_at": "2025-12-29T03:56:13Z",
-  "updated_at": "2025-12-29T03:57:09Z",
-  "published_at": "2025-12-29T03:57:08Z",
+  "created_at": "2026-01-19T05:08:35Z",
+  "updated_at": "2026-01-19T05:09:41Z",
+  "published_at": "2026-01-19T05:09:31Z",
   "assets": [
     {
-      "url": "https://api.github.com/repos/SentienceAPI/Sentience-Geometry-Chrome-Extension/releases/assets/333966751",
-      "id": 333966751,
-      "node_id": "RA_kwDOQshiJ84T5-2f",
+      "url": "https://api.github.com/repos/SentienceAPI/Sentience-Geometry-Chrome-Extension/releases/assets/342599449",
+      "id": 342599449,
+      "node_id": "RA_kwDOQshiJ84Ua6cZ",
       "name": "extension-files.tar.gz",
       "label": "",
       "uploader": {
@@ -65,17 +65,17 @@
       },
       "content_type": "application/gzip",
       "state": "uploaded",
-      "size": 78091,
-      "digest": "sha256:e281f8b755b61da4b8015d6172064aa9a337c14133ceceff4ab29199ee53307e",
-      "download_count": 5,
-      "created_at": "2025-12-29T03:57:09Z",
-      "updated_at": "2025-12-29T03:57:09Z",
-      "browser_download_url": "https://github.com/SentienceAPI/Sentience-Geometry-Chrome-Extension/releases/download/v2.0.7/extension-files.tar.gz"
+      "size": 79222,
+      "digest": "sha256:e0cad96e20e539d62a4777f1c5baedb1c8bd02cd26a8e38f7c1b9c804325f068",
+      "download_count": 0,
+      "created_at": "2026-01-19T05:09:41Z",
+      "updated_at": "2026-01-19T05:09:41Z",
+      "browser_download_url": "https://github.com/SentienceAPI/Sentience-Geometry-Chrome-Extension/releases/download/v2.7.0/extension-files.tar.gz"
     },
     {
-      "url": "https://api.github.com/repos/SentienceAPI/Sentience-Geometry-Chrome-Extension/releases/assets/333966752",
-      "id": 333966752,
-      "node_id": "RA_kwDOQshiJ84T5-2g",
+      "url": "https://api.github.com/repos/SentienceAPI/Sentience-Geometry-Chrome-Extension/releases/assets/342599448",
+      "id": 342599448,
+      "node_id": "RA_kwDOQshiJ84Ua6cY",
       "name": "extension-package.zip",
       "label": "",
       "uploader": {
@@ -101,15 +101,15 @@
       },
       "content_type": "application/zip",
       "state": "uploaded",
-      "size": 80179,
-      "digest": "sha256:a025edeb8b6d05bfb25c57f913b68507060653ecbdf616000a46df4cb8dec377",
+      "size": 80692,
+      "digest": "sha256:83de4c4c54f401fc6404c27ef01a9205cf8e3566e81f62a7bc08f7103a2b0cc5",
       "download_count": 0,
-      "created_at": "2025-12-29T03:57:09Z",
-      "updated_at": "2025-12-29T03:57:09Z",
-      "browser_download_url": "https://github.com/SentienceAPI/Sentience-Geometry-Chrome-Extension/releases/download/v2.0.7/extension-package.zip"
+      "created_at": "2026-01-19T05:09:41Z",
+      "updated_at": "2026-01-19T05:09:41Z",
+      "browser_download_url": "https://github.com/SentienceAPI/Sentience-Geometry-Chrome-Extension/releases/download/v2.7.0/extension-package.zip"
     }
   ],
-  "tarball_url": "https://api.github.com/repos/SentienceAPI/Sentience-Geometry-Chrome-Extension/tarball/v2.0.7",
-  "zipball_url": "https://api.github.com/repos/SentienceAPI/Sentience-Geometry-Chrome-Extension/zipball/v2.0.7",
-  "body": "**Full Changelog**: https://github.com/SentienceAPI/Sentience-Geometry-Chrome-Extension/compare/v2.0.6...v2.0.7"
+  "tarball_url": "https://api.github.com/repos/SentienceAPI/Sentience-Geometry-Chrome-Extension/tarball/v2.7.0",
+  "zipball_url": "https://api.github.com/repos/SentienceAPI/Sentience-Geometry-Chrome-Extension/zipball/v2.7.0",
+  "body": ""
 }

sentience/failure_artifacts.py

@@ -0,0 +1,241 @@
+from __future__ import annotations
+
+import json
+import shutil
+import tempfile
+import time
+from collections.abc import Callable
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Literal
+
+
+@dataclass
+class FailureArtifactsOptions:
+    buffer_seconds: float = 15.0
+    capture_on_action: bool = True
+    fps: float = 0.0
+    persist_mode: Literal["onFail", "always"] = "onFail"
+    output_dir: str = ".sentience/artifacts"
+    on_before_persist: Callable[[RedactionContext], RedactionResult] | None = None
+    redact_snapshot_values: bool = True
+
+
+@dataclass
+class RedactionContext:
+    run_id: str
+    reason: str | None
+    status: Literal["failure", "success"]
+    snapshot: Any | None
+    diagnostics: Any | None
+    frame_paths: list[str]
+    metadata: dict[str, Any]
+
+
+@dataclass
+class RedactionResult:
+    snapshot: Any | None = None
+    diagnostics: Any | None = None
+    frame_paths: list[str] | None = None
+    drop_frames: bool = False
+
+
+@dataclass
+class _FrameRecord:
+    ts: float
+    file_name: str
+    path: Path
+
+
+class FailureArtifactBuffer:
+    """
+    Ring buffer of screenshots with minimal persistence on failure.
+    """
+
+    def __init__(
+        self,
+        *,
+        run_id: str,
+        options: FailureArtifactsOptions,
+        time_fn: Callable[[], float] = time.time,
+    ) -> None:
+        self.run_id = run_id
+        self.options = options
+        self._time_fn = time_fn
+        self._temp_dir = Path(tempfile.mkdtemp(prefix="sentience-artifacts-"))
+        self._frames_dir = self._temp_dir / "frames"
+        self._frames_dir.mkdir(parents=True, exist_ok=True)
+        self._frames: list[_FrameRecord] = []
+        self._steps: list[dict] = []
+        self._persisted = False
+
+    @property
+    def temp_dir(self) -> Path:
+        return self._temp_dir
+
+    def record_step(
+        self,
+        *,
+        action: str,
+        step_id: str | None,
+        step_index: int | None,
+        url: str | None,
+    ) -> None:
+        self._steps.append(
+            {
+                "ts": self._time_fn(),
+                "action": action,
+                "step_id": step_id,
+                "step_index": step_index,
+                "url": url,
+            }
+        )
+
+    def add_frame(self, image_bytes: bytes, *, fmt: str = "png") -> None:
+        ts = self._time_fn()
+        file_name = f"frame_{int(ts * 1000)}.{fmt}"
+        path = self._frames_dir / file_name
+        path.write_bytes(image_bytes)
+        self._frames.append(_FrameRecord(ts=ts, file_name=file_name, path=path))
+        self._prune()
+
+    def frame_count(self) -> int:
+        return len(self._frames)
+
+    def _prune(self) -> None:
+        cutoff = self._time_fn() - max(0.0, self.options.buffer_seconds)
+        keep: list[_FrameRecord] = []
+        for frame in self._frames:
+            if frame.ts >= cutoff:
+                keep.append(frame)
+            else:
+                try:
+                    frame.path.unlink(missing_ok=True)
+                except Exception:
+                    pass
+        self._frames = keep
+
+    def _write_json_atomic(self, path: Path, data: Any) -> None:
+        tmp_path = path.with_suffix(path.suffix + ".tmp")
+        tmp_path.write_text(json.dumps(data, indent=2))
+        tmp_path.replace(path)
+
+    def _redact_snapshot_defaults(self, payload: Any) -> Any:
+        if not isinstance(payload, dict):
+            return payload
+        elements = payload.get("elements")
+        if not isinstance(elements, list):
+            return payload
+        redacted = []
+        for el in elements:
+            if not isinstance(el, dict):
+                redacted.append(el)
+                continue
+            input_type = (el.get("input_type") or "").lower()
+            if input_type in {"password", "email", "tel"} and "value" in el:
+                el = dict(el)
+                el["value"] = None
+                el["value_redacted"] = True
+            redacted.append(el)
+        payload = dict(payload)
+        payload["elements"] = redacted
+        return payload
+
+    def persist(
+        self,
+        *,
+        reason: str | None,
+        status: Literal["failure", "success"],
+        snapshot: Any | None = None,
+        diagnostics: Any | None = None,
+        metadata: dict[str, Any] | None = None,
+    ) -> Path | None:
+        if self._persisted:
+            return None
+
+        output_dir = Path(self.options.output_dir)
+        output_dir.mkdir(parents=True, exist_ok=True)
+        ts = int(self._time_fn() * 1000)
+        run_dir = output_dir / f"{self.run_id}-{ts}"
+        frames_out = run_dir / "frames"
+        frames_out.mkdir(parents=True, exist_ok=True)
+
+        snapshot_payload = None
+        if snapshot is not None:
+            if hasattr(snapshot, "model_dump"):
+                snapshot_payload = snapshot.model_dump()
+            else:
+                snapshot_payload = snapshot
+            if self.options.redact_snapshot_values:
+                snapshot_payload = self._redact_snapshot_defaults(snapshot_payload)
+
+        diagnostics_payload = None
+        if diagnostics is not None:
+            if hasattr(diagnostics, "model_dump"):
+                diagnostics_payload = diagnostics.model_dump()
+            else:
+                diagnostics_payload = diagnostics
+
+        frame_paths = [str(frame.path) for frame in self._frames]
+        drop_frames = False
+
+        if self.options.on_before_persist is not None:
+            try:
+                result = self.options.on_before_persist(
+                    RedactionContext(
+                        run_id=self.run_id,
+                        reason=reason,
+                        status=status,
+                        snapshot=snapshot_payload,
+                        diagnostics=diagnostics_payload,
+                        frame_paths=frame_paths,
+                        metadata=metadata or {},
+                    )
+                )
+                if result.snapshot is not None:
+                    snapshot_payload = result.snapshot
+                if result.diagnostics is not None:
+                    diagnostics_payload = result.diagnostics
+                if result.frame_paths is not None:
+                    frame_paths = result.frame_paths
+                drop_frames = result.drop_frames
+            except Exception:
+                drop_frames = True
+
+        if not drop_frames:
+            for frame_path in frame_paths:
+                src = Path(frame_path)
+                if not src.exists():
+                    continue
+                shutil.copy2(src, frames_out / src.name)
+
+        self._write_json_atomic(run_dir / "steps.json", self._steps)
+        if snapshot_payload is not None:
+            self._write_json_atomic(run_dir / "snapshot.json", snapshot_payload)
+        if diagnostics_payload is not None:
+            self._write_json_atomic(run_dir / "diagnostics.json", diagnostics_payload)
+
+        manifest = {
+            "run_id": self.run_id,
+            "created_at_ms": ts,
+            "status": status,
+            "reason": reason,
+            "buffer_seconds": self.options.buffer_seconds,
+            "frame_count": 0 if drop_frames else len(frame_paths),
+            "frames": (
+                [] if drop_frames else [{"file": Path(p).name, "ts": None} for p in frame_paths]
+            ),
+            "snapshot": "snapshot.json" if snapshot_payload is not None else None,
+            "diagnostics": "diagnostics.json" if diagnostics_payload is not None else None,
+            "metadata": metadata or {},
+            "frames_redacted": not drop_frames and self.options.on_before_persist is not None,
+            "frames_dropped": drop_frames,
+        }
+        self._write_json_atomic(run_dir / "manifest.json", manifest)
+
+        self._persisted = True
+        return run_dir
+
+    def cleanup(self) -> None:
+        if self._temp_dir.exists():
+            shutil.rmtree(self._temp_dir, ignore_errors=True)

sentience/formatting.py

@@ -1,59 +1,15 @@
 """
 Snapshot formatting utilities for LLM prompts.
 
-Provides functions to convert Sentience snapshots into text format suitable
-for LLM consumption.
-"""
-
-from typing import List
-
-from .models import Snapshot
-
-
-def format_snapshot_for_llm(snap: Snapshot, limit: int = 50) -> str:
-    """
-    Convert snapshot elements to text format for LLM consumption.
-
-    This is the canonical way Sentience formats DOM state for LLMs.
-    The format includes element ID, role, text preview, visual cues,
-    position, and importance score.
+DEPRECATED: This module is maintained for backward compatibility only.
+New code should import from sentience.utils.formatting or sentience directly:
 
-    Args:
-        snap: Snapshot object with elements
-        limit: Maximum number of elements to include (default: 50)
-
-    Returns:
-        Formatted string with one element per line
-
-    Example:
-        >>> snap = snapshot(browser)
-        >>> formatted = format_snapshot_for_llm(snap, limit=10)
-        >>> print(formatted)
-        [1] <button> "Sign In" {PRIMARY,CLICKABLE} @ (100,50) (Imp:10)
-        [2] <input> "Email address" @ (100,100) (Imp:8)
-        ...
-    """
-    lines: list[str] = []
-
-    for el in snap.elements[:limit]:
-        # Build visual cues string
-        cues = []
-        if getattr(el.visual_cues, "is_primary", False):
-            cues.append("PRIMARY")
-        if getattr(el.visual_cues, "is_clickable", False):
-            cues.append("CLICKABLE")
-
-        cues_str = f" {{{','.join(cues)}}}" if cues else ""
-
-        # Format text preview (truncate to 50 chars)
-        text_preview = el.text or ""
-        if len(text_preview) > 50:
-            text_preview = text_preview[:50] + "..."
+    from sentience.utils.formatting import format_snapshot_for_llm
+    # or
+    from sentience import format_snapshot_for_llm
+"""
 
-        # Build element line: [ID] <role> "text" {cues} @ (x,y) (Imp:score)
-        lines.append(
-            f'[{el.id}] <{el.role}> "{text_preview}"{cues_str} '
-            f"@ ({int(el.bbox.x)},{int(el.bbox.y)}) (Imp:{el.importance})"
-        )
+# Re-export from new location for backward compatibility
+from .utils.formatting import format_snapshot_for_llm
 
-    return "\n".join(lines)
+__all__ = ["format_snapshot_for_llm"]

sentience/inspector.py

@@ -1,8 +1,10 @@
+from typing import Optional
+
 """
 Inspector tool - helps developers see what the agent "sees"
 """
 
-from .browser import SentienceBrowser
+from .browser import AsyncSentienceBrowser, SentienceBrowser
 
 
 class Inspector:
@@ -183,3 +185,183 @@ def inspect(browser: SentienceBrowser) -> Inspector:
         Inspector instance
     """
     return Inspector(browser)
+
+
+class InspectorAsync:
+    """Inspector for debugging - shows element info on hover/click (async)"""
+
+    def __init__(self, browser: AsyncSentienceBrowser):
+        self.browser = browser
+        self._active = False
+        self._last_element_id: int | None = None
+
+    async def start(self) -> None:
+        """Start inspection mode - prints element info on mouse move/click (async)"""
+        if not self.browser.page:
+            raise RuntimeError("Browser not started. Call await browser.start() first.")
+
+        self._active = True
+
+        # Inject inspector script into page
+        await self.browser.page.evaluate(
+            """
+            (() => {
+                // Remove existing inspector if any
+                if (window.__sentience_inspector_active) {
+                    return;
+                }
+
+                window.__sentience_inspector_active = true;
+                window.__sentience_last_element_id = null;
+
+                // Get element at point
+                function getElementAtPoint(x, y) {
+                    const el = document.elementFromPoint(x, y);
+                    if (!el) return null;
+
+                    // Find element in registry
+                    if (window.sentience_registry) {
+                        for (let i = 0; i < window.sentience_registry.length; i++) {
+                            if (window.sentience_registry[i] === el) {
+                                return i;
+                            }
+                        }
+                    }
+                    return null;
+                }
+
+                // Mouse move handler
+                function handleMouseMove(e) {
+                    if (!window.__sentience_inspector_active) return;
+
+                    const elementId = getElementAtPoint(e.clientX, e.clientY);
+                    if (elementId === null || elementId === window.__sentience_last_element_id) {
+                        return;
+                    }
+
+                    window.__sentience_last_element_id = elementId;
+
+                    // Get element info from snapshot if available
+                    if (window.sentience && window.sentience_registry) {
+                        const el = window.sentience_registry[elementId];
+                        if (el) {
+                            const rect = el.getBoundingClientRect();
+                            const text = el.getAttribute('aria-label') ||
+                                        el.value ||
+                                        el.placeholder ||
+                                        el.alt ||
+                                        (el.innerText || '').substring(0, 50);
+
+                            const role = el.getAttribute('role') || el.tagName.toLowerCase();
+
+                            console.log(`[Sentience Inspector] Element #${elementId}: role=${role}, text="${text}", bbox=(${Math.round(rect.x)}, ${Math.round(rect.y)}, ${Math.round(rect.width)}, ${Math.round(rect.height)})`);
+                        }
+                    }
+                }
+
+                // Click handler
+                function handleClick(e) {
+                    if (!window.__sentience_inspector_active) return;
+
+                    e.preventDefault();
+                    e.stopPropagation();
+
+                    const elementId = getElementAtPoint(e.clientX, e.clientY);
+                    if (elementId === null) return;
+
+                    // Get full element info
+                    if (window.sentience && window.sentience_registry) {
+                        const el = window.sentience_registry[elementId];
+                        if (el) {
+                            const rect = el.getBoundingClientRect();
+                            const info = {
+                                id: elementId,
+                                tag: el.tagName.toLowerCase(),
+                                role: el.getAttribute('role') || 'generic',
+                                text: el.getAttribute('aria-label') ||
+                                      el.value ||
+                                      el.placeholder ||
+                                      el.alt ||
+                                      (el.innerText || '').substring(0, 100),
+                                bbox: {
+                                    x: Math.round(rect.x),
+                                    y: Math.round(rect.y),
+                                    width: Math.round(rect.width),
+                                    height: Math.round(rect.height)
+                                },
+                                attributes: {
+                                    id: el.id || null,
+                                    class: el.className || null,
+                                    name: el.name || null,
+                                    type: el.type || null
+                                }
+                            };
+
+                            console.log('[Sentience Inspector] Clicked element:', JSON.stringify(info, null, 2));
+
+                            // Also try to get from snapshot if available
+                            window.sentience.snapshot({ limit: 100 }).then(snap => {
+                                const element = snap.elements.find(el => el.id === elementId);
+                                if (element) {
+                                    console.log('[Sentience Inspector] Snapshot element:', JSON.stringify(element, null, 2));
+                                }
+                            }).catch(() => {});
+                        }
+                    }
+                }
+
+                // Add event listeners
+                document.addEventListener('mousemove', handleMouseMove, true);
+                document.addEventListener('click', handleClick, true);
+
+                // Store cleanup function
+                window.__sentience_inspector_cleanup = () => {
+                    document.removeEventListener('mousemove', handleMouseMove, true);
+                    document.removeEventListener('click', handleClick, true);
+                    window.__sentience_inspector_active = false;
+                };
+
+                console.log('[Sentience Inspector] ✅ Inspection mode active. Hover elements to see info, click to see full details.');
+            })();
+        """
+        )
+
+    async def stop(self) -> None:
+        """Stop inspection mode (async)"""
+        if not self.browser.page:
+            return
+
+        self._active = False
+
+        # Cleanup inspector
+        await self.browser.page.evaluate(
+            """
+            () => {
+                if (window.__sentience_inspector_cleanup) {
+                    window.__sentience_inspector_cleanup();
+                }
+            }
+        """
+        )
+
+    async def __aenter__(self):
+        """Context manager entry"""
+        await self.start()
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        """Context manager exit"""
+        await self.stop()
+
+
+def inspect_async(browser: AsyncSentienceBrowser) -> InspectorAsync:
+    """
+    Create an inspector instance (async)
+
+    Args:
+        browser: AsyncSentienceBrowser instance
+
+    Returns:
+        InspectorAsync instance
+    """
+    return InspectorAsync(browser)

sentience/integrations/__init__.py

@@ -0,0 +1,6 @@
+"""
+Integrations package (internal).
+
+This package is intended for framework integrations (e.g., PydanticAI, LangChain/LangGraph).
+Public APIs should be introduced deliberately once the integration surface is stable.
+"""

sentience/integrations/langchain/__init__.py

@@ -0,0 +1,12 @@
+"""
+LangChain / LangGraph integration helpers (optional).
+
+This package is designed so the base SDK can be imported without LangChain installed.
+All LangChain imports are done lazily inside tool-builder functions.
+"""
+
+from .context import SentienceLangChainContext
+from .core import SentienceLangChainCore
+from .tools import build_sentience_langchain_tools
+
+__all__ = ["SentienceLangChainContext", "SentienceLangChainCore", "build_sentience_langchain_tools"]