langchain-skilllite 0.1.0__py3-none-any.whl

langchain_skilllite/__init__.py

@@ -0,0 +1,54 @@
+"""
+LangChain integration for SkillLite.
+
+This package provides LangChain-compatible tools for executing SkillLite skills
+in a sandboxed environment. It acts as a thin adapter layer on top of the
+skilllite core package.
+
+Key Features:
+- SkillLiteTool: LangChain BaseTool adapter for individual skills
+- SkillLiteToolkit: Convenient toolkit for loading multiple skills
+- Security scanning and confirmation callbacks for sandbox level 3
+- Full async support for LangGraph agents
+
+Installation:
+    pip install langchain-skilllite
+
+Quick Start:
+    ```python
+    from langchain_skilllite import SkillLiteToolkit
+    from langchain_openai import ChatOpenAI
+    from langgraph.prebuilt import create_react_agent
+
+    # Load skills as LangChain tools
+    tools = SkillLiteToolkit.from_directory("./skills")
+
+    # Use with any LangChain agent
+    agent = create_react_agent(ChatOpenAI(), tools)
+    result = agent.invoke({"messages": [("user", "Run my skill")]})
+    ```
+
+For more information, see:
+- SkillLite: https://github.com/EXboys/skilllite
+- LangChain: https://python.langchain.com/
+"""
+
+from langchain_skilllite.tools import (
+    SkillLiteTool,
+    SkillLiteToolkit,
+)
+from langchain_skilllite.callbacks import (
+    SkillLiteCallbackHandler,
+)
+from langchain_skilllite._version import __version__
+
+__all__ = [
+    # Core Tools
+    "SkillLiteTool",
+    "SkillLiteToolkit",
+    # Callbacks
+    "SkillLiteCallbackHandler",
+    # Version
+    "__version__",
+]
+

langchain_skilllite/_version.py

@@ -0,0 +1,4 @@
+"""Version information for langchain-skilllite."""
+
+__version__ = "0.1.0"
+

langchain_skilllite/callbacks.py

@@ -0,0 +1,166 @@
+"""
+LangChain callback handlers for SkillLite.
+
+This module provides callback handlers for integrating SkillLite
+with LangChain's callback system for logging, tracing, and monitoring.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Any, Dict, List, Optional, TYPE_CHECKING, Union
+from uuid import UUID
+
+from langchain_core.callbacks import BaseCallbackHandler
+from langchain_core.outputs import LLMResult
+
+if TYPE_CHECKING:
+    from langchain_core.agents import AgentAction, AgentFinish
+    from langchain_core.messages import BaseMessage
+
+logger = logging.getLogger(__name__)
+
+
+class SkillLiteCallbackHandler(BaseCallbackHandler):
+    """
+    LangChain callback handler for SkillLite skill execution.
+
+    This handler logs skill execution events and can be used for
+    monitoring, debugging, and auditing SkillLite tool usage.
+
+    Usage:
+        from langchain_skilllite import SkillLiteCallbackHandler
+
+        handler = SkillLiteCallbackHandler(verbose=True)
+
+        # Use with LangChain agent
+        agent.invoke({"input": "..."}, config={"callbacks": [handler]})
+
+    Attributes:
+        verbose: Whether to print execution details
+        execution_log: List of execution events
+    """
+
+    def __init__(
+        self,
+        verbose: bool = False,
+        log_level: int = logging.INFO,
+    ):
+        """
+        Initialize the callback handler.
+
+        Args:
+            verbose: If True, print execution details to stdout
+            log_level: Logging level for internal logging
+        """
+        super().__init__()
+        self.verbose = verbose
+        self.log_level = log_level
+        self.execution_log: List[Dict[str, Any]] = []
+        self._current_tool: Optional[str] = None
+
+    def on_tool_start(
+        self,
+        serialized: Dict[str, Any],
+        input_str: str,
+        *,
+        run_id: UUID,
+        parent_run_id: Optional[UUID] = None,
+        tags: Optional[List[str]] = None,
+        metadata: Optional[Dict[str, Any]] = None,
+        inputs: Optional[Dict[str, Any]] = None,
+        **kwargs: Any,
+    ) -> None:
+        """Called when a tool starts running."""
+        tool_name = serialized.get("name", "unknown")
+        self._current_tool = tool_name
+
+        event = {
+            "event": "tool_start",
+            "tool_name": tool_name,
+            "run_id": str(run_id),
+            "input": input_str[:200] if input_str else None,
+        }
+        self.execution_log.append(event)
+
+        if self.verbose:
+            print(f"🔧 [SkillLite] Starting tool: {tool_name}")
+            logger.log(self.log_level, f"Tool started: {tool_name}")
+
+    def on_tool_end(
+        self,
+        output: Any,
+        *,
+        run_id: UUID,
+        parent_run_id: Optional[UUID] = None,
+        **kwargs: Any,
+    ) -> None:
+        """Called when a tool finishes."""
+        # Handle different output types (str, ToolMessage, etc.)
+        if isinstance(output, str):
+            output_preview = output[:200] if output else None
+        elif hasattr(output, "content"):
+            # ToolMessage or similar object
+            content = output.content
+            output_preview = content[:200] if isinstance(content, str) and content else str(content)[:200]
+        else:
+            output_preview = str(output)[:200] if output else None
+
+        event = {
+            "event": "tool_end",
+            "tool_name": self._current_tool,
+            "run_id": str(run_id),
+            "output_preview": output_preview,
+            "success": True,
+        }
+        self.execution_log.append(event)
+
+        if self.verbose:
+            print(f"✅ [SkillLite] Tool completed: {self._current_tool}")
+            logger.log(self.log_level, f"Tool completed: {self._current_tool}")
+
+        self._current_tool = None
+
+    def on_tool_error(
+        self,
+        error: BaseException,
+        *,
+        run_id: UUID,
+        parent_run_id: Optional[UUID] = None,
+        **kwargs: Any,
+    ) -> None:
+        """Called when a tool errors."""
+        event = {
+            "event": "tool_error",
+            "tool_name": self._current_tool,
+            "run_id": str(run_id),
+            "error": str(error),
+            "success": False,
+        }
+        self.execution_log.append(event)
+
+        if self.verbose:
+            print(f"❌ [SkillLite] Tool error: {self._current_tool} - {error}")
+            logger.error(f"Tool error: {self._current_tool} - {error}")
+
+        self._current_tool = None
+
+    def get_execution_summary(self) -> Dict[str, Any]:
+        """Get a summary of all execution events."""
+        total = len(self.execution_log)
+        tool_starts = sum(1 for e in self.execution_log if e["event"] == "tool_start")
+        tool_ends = sum(1 for e in self.execution_log if e["event"] == "tool_end")
+        tool_errors = sum(1 for e in self.execution_log if e["event"] == "tool_error")
+
+        return {
+            "total_events": total,
+            "tool_executions": tool_starts,
+            "successful": tool_ends,
+            "errors": tool_errors,
+            "success_rate": tool_ends / tool_starts if tool_starts > 0 else 0,
+        }
+
+    def clear_log(self) -> None:
+        """Clear the execution log."""
+        self.execution_log.clear()
+

langchain_skilllite/tools.py

@@ -0,0 +1,526 @@
+"""
+LangChain tools for SkillLite skill execution.
+
+This module provides LangChain-compatible tool wrappers for SkillLite skills.
+All execution logic is delegated to the skilllite core package.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import hashlib
+import os
+import time
+import uuid
+from dataclasses import dataclass, field
+from typing import Any, Callable, Dict, List, Optional, Type, TYPE_CHECKING
+
+from langchain_core.tools import BaseTool
+from langchain_core.callbacks import (
+    CallbackManagerForToolRun,
+    AsyncCallbackManagerForToolRun,
+)
+from pydantic import BaseModel, Field, ConfigDict
+
+# Import from skilllite core - this is the key dependency
+from skilllite import SkillManager, SkillInfo
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+# Type aliases for confirmation callbacks
+ConfirmationCallback = Callable[[str, str], bool]
+AsyncConfirmationCallback = Callable[[str, str], "asyncio.Future[bool]"]
+
+
+@dataclass
+class SecurityScanResult:
+    """Result of a security scan for skill execution."""
+
+    is_safe: bool
+    issues: List[Dict[str, Any]] = field(default_factory=list)
+    scan_id: str = ""
+    code_hash: str = ""
+    high_severity_count: int = 0
+    medium_severity_count: int = 0
+    low_severity_count: int = 0
+    timestamp: float = field(default_factory=time.time)
+
+    @property
+    def requires_confirmation(self) -> bool:
+        """Check if user confirmation is required."""
+        return self.high_severity_count > 0
+
+    def format_report(self) -> str:
+        """Format a human-readable security report."""
+        if not self.issues:
+            return "✅ Security scan passed. No issues found."
+
+        lines = [
+            f"📋 Security Scan Report (ID: {self.scan_id[:8]})",
+            f"   Found {len(self.issues)} item(s) for review:",
+            "",
+        ]
+
+        severity_icons = {
+            "Critical": "🔴",
+            "High": "🟠",
+            "Medium": "🟡",
+            "Low": "🟢",
+        }
+
+        for idx, issue in enumerate(self.issues, 1):
+            severity = issue.get("severity", "Medium")
+            icon = severity_icons.get(severity, "⚪")
+            lines.append(f"  {icon} #{idx} [{severity}] {issue.get('issue_type', 'Unknown')}")
+            lines.append(f"     ├─ Rule: {issue.get('rule_id', 'N/A')}")
+            lines.append(f"     ├─ Line {issue.get('line_number', '?')}: {issue.get('description', '')}")
+            snippet = issue.get('code_snippet', '')
+            lines.append(f"     └─ Code: {snippet[:60]}{'...' if len(snippet) > 60 else ''}")
+            lines.append("")
+
+        if self.high_severity_count > 0:
+            lines.append("⚠️  High severity issues found. Confirmation required to execute.")
+        else:
+            lines.append("ℹ️  Only low/medium severity issues found. Safe to execute.")
+
+        return "\n".join(lines)
+
+
+class SkillLiteTool(BaseTool):
+    """
+    LangChain BaseTool adapter for a single SkillLite skill.
+
+    This wraps a SkillLite skill as a LangChain tool, enabling it to be
+    used with LangChain agents and LangGraph.
+
+    All execution is delegated to the skilllite core package.
+
+    Attributes:
+        name: Tool name (same as skill name)
+        description: Tool description from SKILL.md
+        manager: SkillManager instance (from skilllite)
+        skill_name: Name of the skill to execute
+        sandbox_level: Sandbox security level (1/2/3)
+    """
+
+    name: str = Field(description="Tool name")
+    description: str = Field(description="Tool description")
+    args_schema: Optional[Type[BaseModel]] = Field(
+        default=None, description="Pydantic schema for arguments"
+    )
+
+    # SkillLite specific fields - delegated to skilllite core
+    manager: Any = Field(exclude=True)  # SkillManager instance
+    skill_name: str = Field(description="SkillLite skill name")
+    allow_network: bool = Field(default=False, description="Allow network access")
+    timeout: Optional[int] = Field(default=None, description="Execution timeout in seconds")
+
+    # Security confirmation fields
+    sandbox_level: int = Field(default=3, description="Sandbox security level (1/2/3)")
+    confirmation_callback: Optional[Any] = Field(
+        default=None,
+        exclude=True,
+        description="Sync callback: (report: str, scan_id: str) -> bool"
+    )
+    async_confirmation_callback: Optional[Any] = Field(
+        default=None,
+        exclude=True,
+        description="Async callback: (report: str, scan_id: str) -> Future[bool]"
+    )
+
+    # Internal cache
+    _scan_cache: Dict[str, SecurityScanResult] = {}
+    _confirmed_skills: Dict[str, float] = {}  # skill_name -> confirmation timestamp
+    _SCAN_CACHE_TTL: int = 300  # 5 minutes
+    _CONFIRMATION_TTL: int = 3600  # 1 hour - once confirmed, don't ask again
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    def _generate_input_hash(self, input_data: Dict[str, Any]) -> str:
+        """Generate a hash of the input data for verification."""
+        import json
+        content = json.dumps(input_data, sort_keys=True, ensure_ascii=False)
+        return hashlib.sha256(content.encode()).hexdigest()[:16]
+
+    def _cleanup_expired_scans(self) -> None:
+        """Remove expired scan results from cache."""
+        current_time = time.time()
+        expired_keys = [
+            k for k, v in self._scan_cache.items()
+            if current_time - v.timestamp > self._SCAN_CACHE_TTL
+        ]
+        for key in expired_keys:
+            del self._scan_cache[key]
+
+    def _perform_security_scan(self, input_data: Dict[str, Any]) -> SecurityScanResult:
+        """
+        Perform a security scan on the skill execution.
+        Delegates to skilllite's skillbox binary for actual scanning.
+        """
+        self._cleanup_expired_scans()
+        input_hash = self._generate_input_hash(input_data)
+        scan_id = str(uuid.uuid4())
+
+        try:
+            # Get skill info from skilllite's registry
+            skill_info = self.manager._registry.get_skill(self.skill_name)
+            entry_point = skill_info.metadata.entry_point if skill_info and skill_info.metadata else None
+
+            if skill_info and entry_point:
+                entry_script = skill_info.path / entry_point
+                if entry_script.exists():
+                    # Use skilllite's skillbox for security scanning
+                    from skilllite.sandbox.skillbox import find_binary
+                    import subprocess
+
+                    skillbox_path = find_binary()
+                    if skillbox_path:
+                        result = subprocess.run(
+                            [skillbox_path, "security-scan", str(entry_script)],
+                            capture_output=True,
+                            text=True,
+                            timeout=30
+                        )
+                        issues = self._parse_scan_output(result.stdout + result.stderr)
+                        high_count = sum(1 for i in issues if i.get("severity") in ["Critical", "High"])
+                        medium_count = sum(1 for i in issues if i.get("severity") == "Medium")
+                        low_count = sum(1 for i in issues if i.get("severity") == "Low")
+
+                        scan_result = SecurityScanResult(
+                            is_safe=high_count == 0,
+                            issues=issues,
+                            scan_id=scan_id,
+                            code_hash=input_hash,
+                            high_severity_count=high_count,
+                            medium_severity_count=medium_count,
+                            low_severity_count=low_count,
+                        )
+                        self._scan_cache[scan_id] = scan_result
+                        return scan_result
+        except Exception:
+            pass
+
+        # Default: no issues found
+        scan_result = SecurityScanResult(
+            is_safe=True,
+            issues=[],
+            scan_id=scan_id,
+            code_hash=input_hash,
+        )
+        self._scan_cache[scan_id] = scan_result
+        return scan_result
+
+    def _parse_scan_output(self, output: str) -> List[Dict[str, Any]]:
+        """Parse skillbox scan output into structured issues."""
+        issues = []
+        current_issue: Optional[Dict[str, Any]] = None
+
+        for line in output.split('\n'):
+            line = line.strip()
+            if not line:
+                continue
+
+            if any(sev in line for sev in ['[Critical]', '[High]', '[Medium]', '[Low]']):
+                if current_issue:
+                    issues.append(current_issue)
+
+                severity = "Medium"
+                for sev in ['Critical', 'High', 'Medium', 'Low']:
+                    if f'[{sev}]' in line:
+                        severity = sev
+                        break
+
+                current_issue = {
+                    "severity": severity,
+                    "issue_type": "SecurityIssue",
+                    "description": line,
+                    "rule_id": "unknown",
+                    "line_number": 0,
+                    "code_snippet": ""
+                }
+            elif current_issue:
+                if 'Rule:' in line:
+                    current_issue["rule_id"] = line.split('Rule:')[-1].strip()
+                elif 'Line' in line:
+                    try:
+                        line_num = int(line.split('Line')[-1].split(':')[0].strip())
+                        current_issue["line_number"] = line_num
+                    except ValueError:
+                        pass
+                elif 'Code:' in line or '│' in line:
+                    current_issue["code_snippet"] = line.split('Code:')[-1].strip() if 'Code:' in line else line
+
+        if current_issue:
+            issues.append(current_issue)
+
+        return issues
+
+    def _is_skill_confirmed(self) -> bool:
+        """Check if this skill has been confirmed recently."""
+        if self.skill_name in self._confirmed_skills:
+            confirmed_at = self._confirmed_skills[self.skill_name]
+            if time.time() - confirmed_at < self._CONFIRMATION_TTL:
+                return True
+            # Expired, remove from cache
+            del self._confirmed_skills[self.skill_name]
+        return False
+
+    def _mark_skill_confirmed(self) -> None:
+        """Mark this skill as confirmed."""
+        self._confirmed_skills[self.skill_name] = time.time()
+
+    def _run(
+        self,
+        run_manager: Optional[CallbackManagerForToolRun] = None,
+        **kwargs: Any
+    ) -> str:
+        """Execute the skill synchronously. Delegates to skilllite core."""
+        skip_skillbox_confirmation = False
+        old_sandbox_level = None
+
+        try:
+            # Security scan for sandbox level 3
+            if self.sandbox_level >= 3:
+                # Check if already confirmed in this session
+                if self._is_skill_confirmed():
+                    skip_skillbox_confirmation = True
+                else:
+                    scan_result = self._perform_security_scan(kwargs)
+
+                    if scan_result.requires_confirmation:
+                        if self.confirmation_callback:
+                            report = scan_result.format_report()
+                            confirmed = self.confirmation_callback(report, scan_result.scan_id)
+
+                            if not confirmed:
+                                return (
+                                    f"🔐 Execution cancelled by user.\n\n"
+                                    f"{report}\n\n"
+                                    f"User declined to proceed with execution."
+                                )
+                            # Mark as confirmed so we don't ask again
+                            self._mark_skill_confirmed()
+                            skip_skillbox_confirmation = True
+                        else:
+                            return (
+                                f"🔐 Security Review Required\n\n"
+                                f"{scan_result.format_report()}\n\n"
+                                f"Provide a confirmation_callback when creating the tool."
+                            )
+
+            # Adjust sandbox level if user confirmed
+            if skip_skillbox_confirmation:
+                old_sandbox_level = os.environ.get("SKILLBOX_SANDBOX_LEVEL")
+                os.environ["SKILLBOX_SANDBOX_LEVEL"] = "1"
+
+            # Delegate execution to skilllite core
+            result = self.manager.execute(
+                self.skill_name,
+                kwargs,
+                allow_network=self.allow_network,
+                timeout=self.timeout
+            )
+            if result.success:
+                return result.output or "Execution completed successfully"
+            else:
+                return f"Error: {result.error}"
+        except Exception as e:
+            return f"Execution failed: {str(e)}"
+        finally:
+            if skip_skillbox_confirmation:
+                if old_sandbox_level is not None:
+                    os.environ["SKILLBOX_SANDBOX_LEVEL"] = old_sandbox_level
+                elif "SKILLBOX_SANDBOX_LEVEL" in os.environ:
+                    del os.environ["SKILLBOX_SANDBOX_LEVEL"]
+
+    async def _arun(
+        self,
+        run_manager: Optional[AsyncCallbackManagerForToolRun] = None,
+        **kwargs: Any
+    ) -> str:
+        """Execute the skill asynchronously. Delegates to skilllite core."""
+        skip_skillbox_confirmation = False
+        old_sandbox_level = None
+
+        try:
+            if self.sandbox_level >= 3:
+                # Check if already confirmed in this session
+                if self._is_skill_confirmed():
+                    skip_skillbox_confirmation = True
+                else:
+                    scan_result = await asyncio.to_thread(self._perform_security_scan, kwargs)
+
+                    if scan_result.requires_confirmation:
+                        if self.async_confirmation_callback:
+                            report = scan_result.format_report()
+                            confirmed = await self.async_confirmation_callback(report, scan_result.scan_id)
+                            if not confirmed:
+                                return f"🔐 Execution cancelled by user.\n\n{report}"
+                            self._mark_skill_confirmed()
+                            skip_skillbox_confirmation = True
+                        elif self.confirmation_callback:
+                            report = scan_result.format_report()
+                            confirmed = await asyncio.to_thread(
+                                self.confirmation_callback, report, scan_result.scan_id
+                            )
+                            if not confirmed:
+                                return f"🔐 Execution cancelled by user.\n\n{report}"
+                            self._mark_skill_confirmed()
+                            skip_skillbox_confirmation = True
+                        else:
+                            return (
+                                f"🔐 Security Review Required\n\n"
+                                f"{scan_result.format_report()}"
+                            )
+
+            if skip_skillbox_confirmation:
+                old_sandbox_level = os.environ.get("SKILLBOX_SANDBOX_LEVEL")
+                os.environ["SKILLBOX_SANDBOX_LEVEL"] = "1"
+
+            # Delegate to skilllite core
+            result = await asyncio.to_thread(
+                self.manager.execute,
+                self.skill_name,
+                kwargs,
+                self.allow_network,
+                self.timeout
+            )
+            if result.success:
+                return result.output or "Execution completed successfully"
+            else:
+                return f"Error: {result.error}"
+        except Exception as e:
+            return f"Execution failed: {str(e)}"
+        finally:
+            if skip_skillbox_confirmation:
+                if old_sandbox_level is not None:
+                    os.environ["SKILLBOX_SANDBOX_LEVEL"] = old_sandbox_level
+                elif "SKILLBOX_SANDBOX_LEVEL" in os.environ:
+                    del os.environ["SKILLBOX_SANDBOX_LEVEL"]
+
+
+class SkillLiteToolkit:
+    """
+    LangChain Toolkit for SkillLite.
+
+    Provides a convenient way to create LangChain tools from all skills
+    registered in a SkillManager.
+
+    Usage:
+        manager = SkillManager(skills_dir="./skills")
+        tools = SkillLiteToolkit.from_manager(manager)
+
+        # Or with options
+        tools = SkillLiteToolkit.from_manager(
+            manager,
+            skill_names=["calculator", "web_search"],
+            allow_network=True,
+            timeout=60
+        )
+
+        # With security confirmation callback (for sandbox level 3)
+        def confirm_execution(report: str, scan_id: str) -> bool:
+            print(report)
+            return input("Continue? [y/N]: ").lower() == 'y'
+
+        tools = SkillLiteToolkit.from_manager(
+            manager,
+            sandbox_level=3,
+            confirmation_callback=confirm_execution
+        )
+    """
+
+    @staticmethod
+    def from_manager(
+        manager: "SkillManager",
+        skill_names: Optional[List[str]] = None,
+        allow_network: bool = False,
+        timeout: Optional[int] = None,
+        sandbox_level: int = 3,
+        confirmation_callback: Optional[ConfirmationCallback] = None,
+        async_confirmation_callback: Optional[AsyncConfirmationCallback] = None,
+    ) -> List[SkillLiteTool]:
+        """
+        Create LangChain tools from a SkillManager.
+
+        Args:
+            manager: SkillManager instance with registered skills
+            skill_names: Optional list of skill names to include (default: all)
+            allow_network: Whether to allow network access for all tools
+            timeout: Execution timeout in seconds for all tools
+            sandbox_level: Sandbox security level (1/2/3, default: 3)
+                - Level 1: No sandbox - direct execution
+                - Level 2: Sandbox isolation only
+                - Level 3: Sandbox + security scanning (requires confirmation)
+            confirmation_callback: Sync callback for security confirmation.
+                Signature: (security_report: str, scan_id: str) -> bool
+            async_confirmation_callback: Async callback for security confirmation.
+                Signature: (security_report: str, scan_id: str) -> Future[bool]
+
+        Returns:
+            List of SkillLiteTool instances
+        """
+        tools = []
+
+        # Get executable skills from skilllite core
+        skills = manager.list_executable_skills()
+
+        for skill in skills:
+            # Filter by name if specified
+            if skill_names and skill.name not in skill_names:
+                continue
+
+            # Create tool with security confirmation support
+            tool = SkillLiteTool(
+                name=skill.name,
+                description=skill.description or f"Execute the {skill.name} skill",
+                manager=manager,
+                skill_name=skill.name,
+                allow_network=allow_network,
+                timeout=timeout,
+                sandbox_level=sandbox_level,
+                confirmation_callback=confirmation_callback,
+                async_confirmation_callback=async_confirmation_callback,
+            )
+            tools.append(tool)
+
+        return tools
+
+    @staticmethod
+    def from_directory(
+        skills_dir: str,
+        skill_names: Optional[List[str]] = None,
+        allow_network: bool = False,
+        timeout: Optional[int] = None,
+        sandbox_level: int = 3,
+        confirmation_callback: Optional[ConfirmationCallback] = None,
+        async_confirmation_callback: Optional[AsyncConfirmationCallback] = None,
+    ) -> List[SkillLiteTool]:
+        """
+        Create LangChain tools from a skills directory.
+
+        Convenience method that creates a SkillManager and loads all skills.
+
+        Args:
+            skills_dir: Path to directory containing skill folders
+            skill_names: Optional list of skill names to include
+            allow_network: Whether to allow network access
+            timeout: Execution timeout in seconds
+            sandbox_level: Sandbox security level (1/2/3)
+            confirmation_callback: Sync callback for security confirmation
+            async_confirmation_callback: Async callback for security confirmation
+
+        Returns:
+            List of SkillLiteTool instances
+        """
+        manager = SkillManager(skills_dir=skills_dir)
+        return SkillLiteToolkit.from_manager(
+            manager=manager,
+            skill_names=skill_names,
+            allow_network=allow_network,
+            timeout=timeout,
+            sandbox_level=sandbox_level,
+            confirmation_callback=confirmation_callback,
+            async_confirmation_callback=async_confirmation_callback,
+        )

langchain_skilllite-0.1.0.dist-info/METADATA

@@ -0,0 +1,203 @@
+Metadata-Version: 2.4
+Name: langchain-skilllite
+Version: 0.1.0
+Summary: LangChain integration for SkillLite - Lightweight sandboxed Python skill execution engine
+Author-email: SkillLite Team <skilllite@example.com>
+License: MIT
+Project-URL: Homepage, https://github.com/EXboys/langchain-skilllite
+Project-URL: Documentation, https://github.com/EXboys/langchain-skilllite#readme
+Project-URL: Repository, https://github.com/EXboys/langchain-skilllite
+Project-URL: Issues, https://github.com/EXboys/langchain-skilllite/issues
+Project-URL: LangChain, https://python.langchain.com/
+Project-URL: SkillLite, https://github.com/EXboys/skilllite
+Keywords: langchain,skilllite,agent,tools,sandbox,llm,skills,python-execution
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: langchain-core>=0.3.0
+Requires-Dist: skilllite>=0.1.1
+Provides-Extra: langgraph
+Requires-Dist: langgraph>=0.2.0; extra == "langgraph"
+Provides-Extra: test
+Requires-Dist: pytest>=7.0; extra == "test"
+Requires-Dist: pytest-asyncio>=0.21.0; extra == "test"
+Requires-Dist: langchain-tests>=0.3.0; extra == "test"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.21.0; extra == "dev"
+Requires-Dist: langchain-tests>=0.3.0; extra == "dev"
+Requires-Dist: black>=23.0; extra == "dev"
+Requires-Dist: mypy>=1.0; extra == "dev"
+Requires-Dist: ruff>=0.1.0; extra == "dev"
+Dynamic: license-file
+
+# langchain-skilllite
+
+[![PyPI version](https://badge.fury.io/py/langchain-skilllite.svg)](https://badge.fury.io/py/langchain-skilllite)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+LangChain integration for [SkillLite](https://github.com/EXboys/skilllite) - a lightweight sandboxed Python skill execution engine.
+
+## Features
+
+- 🔒 **Sandboxed Execution** - All skills run in a Rust-based sandbox (skillbox)
+- 📝 **Declarative Skills** - Define skills via SKILL.md, no Python wrappers needed
+- 🔍 **Security Scanning** - Pre-execution code analysis for dangerous operations
+- ✅ **Confirmation Callbacks** - User approval for high-severity security issues
+- ⚡ **Async Support** - Full async support for LangGraph agents
+
+## Installation
+
+```bash
+pip install langchain-skilllite
+```
+
+This will also install the required dependencies:
+- `langchain-core>=0.3.0`
+- `skilllite>=0.1.1`
+
+## Quick Start
+
+```python
+from langchain_skilllite import SkillLiteToolkit
+from langchain_openai import ChatOpenAI
+from langgraph.prebuilt import create_react_agent
+
+# Load all skills from a directory as LangChain tools
+tools = SkillLiteToolkit.from_directory("./skills")
+
+# Create a LangGraph agent
+agent = create_react_agent(ChatOpenAI(model="gpt-4"), tools)
+
+# Run the agent
+result = agent.invoke({
+    "messages": [("user", "Calculate 15 + 27 using the calculator skill")]
+})
+```
+
+## Usage
+
+### Basic Usage with SkillManager
+
+```python
+from skilllite import SkillManager
+from langchain_skilllite import SkillLiteToolkit
+
+# Create a SkillManager
+manager = SkillManager(skills_dir="./skills")
+
+# Convert all skills to LangChain tools
+tools = SkillLiteToolkit.from_manager(manager)
+
+# Or select specific skills
+tools = SkillLiteToolkit.from_manager(
+    manager,
+    skill_names=["calculator", "web_search"],
+    allow_network=True,
+    timeout=60
+)
+```
+
+### Security Levels
+
+SkillLite supports three sandbox security levels:
+
+| Level | Description |
+|-------|-------------|
+| 1 | No sandbox - direct execution (fastest, least secure) |
+| 2 | Sandbox isolation only |
+| 3 | Sandbox + security scanning (default, most secure) |
+
+```python
+# Level 3 with confirmation callback for high-severity issues
+def confirm_execution(report: str, scan_id: str) -> bool:
+    print(report)
+    return input("Proceed? [y/N]: ").lower() == 'y'
+
+tools = SkillLiteToolkit.from_directory(
+    "./skills",
+    sandbox_level=3,
+    confirmation_callback=confirm_execution
+)
+```
+
+### Async Confirmation (for LangGraph)
+
+```python
+import asyncio
+
+async def async_confirm(report: str, scan_id: str) -> bool:
+    print(report)
+    # In a real app, this might be a UI prompt
+    return True
+
+tools = SkillLiteToolkit.from_directory(
+    "./skills",
+    sandbox_level=3,
+    async_confirmation_callback=async_confirm
+)
+```
+
+### Callback Handler for Monitoring
+
+```python
+from langchain_skilllite import SkillLiteCallbackHandler
+
+handler = SkillLiteCallbackHandler(verbose=True)
+
+# Use with agent
+result = agent.invoke(
+    {"messages": [("user", "Run my skill")]},
+    config={"callbacks": [handler]}
+)
+
+# Get execution summary
+print(handler.get_execution_summary())
+```
+
+## API Reference
+
+### SkillLiteTool
+
+LangChain `BaseTool` adapter for a single SkillLite skill.
+
+### SkillLiteToolkit
+
+Factory class for creating multiple `SkillLiteTool` instances.
+
+- `from_manager(manager, ...)` - Create tools from a SkillManager
+- `from_directory(skills_dir, ...)` - Create tools from a skills directory
+
+### SkillLiteCallbackHandler
+
+LangChain callback handler for monitoring skill execution.
+
+## Requirements
+
+- Python >= 3.9
+- langchain-core >= 0.3.0
+- skilllite >= 0.1.1
+
+## License
+
+MIT License - see [LICENSE](LICENSE) for details.
+
+## Links
+
+- [SkillLite Repository](https://github.com/EXboys/skilllite)
+- [LangChain Documentation](https://python.langchain.com/)
+- [LangGraph Documentation](https://langchain-ai.github.io/langgraph/)
+

langchain_skilllite-0.1.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+langchain_skilllite/__init__.py,sha256=pkzWP7nP7A_hRsfl0TbgA65WWq-UpMMBCyy4VLslD8Q,1461
+langchain_skilllite/_version.py,sha256=UluS3ysGlayfko8ludKoiC9cT8bp9A2iMfbL6sP5VqQ,75
+langchain_skilllite/callbacks.py,sha256=L-_Qguh_R1jd7Qtx_QN0kaFE5wX7t-9USOoUNaUug6k,5254
+langchain_skilllite/tools.py,sha256=2OBxA2GwNAwnQzYAUmV63FkmI6qB7-r36_LagtVu27E,20921
+langchain_skilllite-0.1.0.dist-info/licenses/LICENSE,sha256=HcK5iz9Y3FKj6oiQH6Q0tx1fYDXhKqkrCUUM8XRngRk,1072
+langchain_skilllite-0.1.0.dist-info/METADATA,sha256=icBeT2u8kwcdN-naTw5zlvaBdsxzD7cdoWzvUjMke84,6077
+langchain_skilllite-0.1.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+langchain_skilllite-0.1.0.dist-info/top_level.txt,sha256=XmA85AHn71wM124Kssl3hQRQElz3JJuDUjtuLJlL7nE,20
+langchain_skilllite-0.1.0.dist-info/RECORD,,

langchain_skilllite-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.10.2)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

langchain_skilllite-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2026 SkillLite Team
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

langchain_skilllite-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+langchain_skilllite