langchain-skilllite 0.1.0__tar.gz

langchain_skilllite-0.1.0/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/PKG-INFO

@@ -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/README.md

@@ -0,0 +1,157 @@
+# 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/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-0.1.0/langchain_skilllite/_version.py

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

langchain_skilllite-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()
+