friday-framework-tools 0.1.0a0__tar.gz

friday_framework_tools-0.1.0a0/.gitignore

@@ -0,0 +1,24 @@
+__pycache__/
+*.pyc
+.env
+.venv/
+.idea/
+.vscode/
+dist/
+build/
+*.egg-info/
+chroma_db/
+.friday/
+/vector/
+/exports/
+tests/integration/memory/vector/*/
+tests/integration/memory/vector/backups/*/
+tests/integration/memory/vector/reorganization_logs/*
+*.gpickle
+keys.txt
+experiments/*/config/runtime.local.yaml
+experiments/*/artifacts/*
+!experiments/*/artifacts/.gitkeep
+scripts/source-friday-chat-example-env.sh
+scripts/pypi.sh
+/docs/reference/PyPI-Recovery-Codes-cichuck-2026-07-20T15_36_49.709334.txt

friday_framework_tools-0.1.0a0/PKG-INFO

@@ -0,0 +1,83 @@
+Metadata-Version: 2.4
+Name: friday-framework-tools
+Version: 0.1.0a0
+Summary: Comprehensive tool library for AI agents
+Project-URL: Homepage, https://github.com/CIChuck/agent-framework
+Project-URL: Repository, https://github.com/CIChuck/agent-framework
+Project-URL: Issues, https://github.com/CIChuck/agent-framework/issues
+Project-URL: Documentation, https://github.com/CIChuck/agent-framework/tree/main/docs
+Project-URL: Source, https://github.com/CIChuck/agent-framework/tree/main/packages/friday-tools
+Author: Friday Team
+License-Expression: MIT
+Keywords: agents,ai,automation,llm,tools
+Requires-Python: >=3.10
+Requires-Dist: beautifulsoup4>=4.12.0
+Requires-Dist: charset-normalizer>=3.3.0
+Requires-Dist: friday-framework-core==0.1.0a0
+Requires-Dist: gitpython>=3.1.0
+Requires-Dist: httpx>=0.25.0
+Requires-Dist: jinja2>=3.1.0
+Requires-Dist: jsonpath-ng>=1.5.0
+Requires-Dist: lxml>=4.9.0
+Requires-Dist: markdownify>=0.11.0
+Requires-Dist: psutil>=7.2.1
+Requires-Dist: python-dateutil>=2.8.0
+Requires-Dist: pyyaml>=6.0.0
+Provides-Extra: all-adapters
+Requires-Dist: anthropic>=0.25.0; extra == 'all-adapters'
+Requires-Dist: langchain-core>=0.1.0; extra == 'all-adapters'
+Requires-Dist: openai>=1.0.0; extra == 'all-adapters'
+Provides-Extra: all-formats
+Requires-Dist: openpyxl>=3.1; extra == 'all-formats'
+Requires-Dist: pypdf>=4.0; extra == 'all-formats'
+Requires-Dist: python-docx>=1.0; extra == 'all-formats'
+Provides-Extra: anthropic
+Requires-Dist: anthropic>=0.25.0; extra == 'anthropic'
+Provides-Extra: dev
+Requires-Dist: pytest-asyncio>=0.23.0; extra == 'dev'
+Requires-Dist: pytest-mock>=3.10.0; extra == 'dev'
+Requires-Dist: pytest>=8.0.0; extra == 'dev'
+Requires-Dist: respx>=0.20.0; extra == 'dev'
+Provides-Extra: documents
+Requires-Dist: pypdf>=4.0; extra == 'documents'
+Requires-Dist: python-docx>=1.0; extra == 'documents'
+Provides-Extra: finance
+Requires-Dist: friday-framework-finance==0.1.0a0; extra == 'finance'
+Provides-Extra: langchain
+Requires-Dist: langchain-core>=0.1.0; extra == 'langchain'
+Provides-Extra: moltbook
+Requires-Dist: friday-framework-moltbook==0.1.0a0; extra == 'moltbook'
+Provides-Extra: openai
+Requires-Dist: openai>=1.0.0; extra == 'openai'
+Provides-Extra: sandbox
+Requires-Dist: friday-framework-sandbox==0.1.0a0; extra == 'sandbox'
+Provides-Extra: spreadsheets
+Requires-Dist: openpyxl>=3.1; extra == 'spreadsheets'
+Description-Content-Type: text/markdown
+
+# Friday Framework Tools
+
+Tool catalog package for the Friday Framework.
+
+This package contains filesystem, shell, web, git, data, text, document,
+memory, finance, code, and integration tools exposed through Friday tool
+contracts.
+
+## Install
+
+```bash
+pip install friday-framework-tools
+```
+
+Optional integrations are available through extras such as `sandbox`,
+`finance`, `moltbook`, `documents`, `spreadsheets`, and adapter extras.
+
+## Import Package
+
+```python
+import friday_tools
+```
+
+## License
+
+MIT

friday_framework_tools-0.1.0a0/README.md

@@ -0,0 +1,26 @@
+# Friday Framework Tools
+
+Tool catalog package for the Friday Framework.
+
+This package contains filesystem, shell, web, git, data, text, document,
+memory, finance, code, and integration tools exposed through Friday tool
+contracts.
+
+## Install
+
+```bash
+pip install friday-framework-tools
+```
+
+Optional integrations are available through extras such as `sandbox`,
+`finance`, `moltbook`, `documents`, `spreadsheets`, and adapter extras.
+
+## Import Package
+
+```python
+import friday_tools
+```
+
+## License
+
+MIT

friday_framework_tools-0.1.0a0/pyproject.toml

@@ -0,0 +1,107 @@
+[project]
+name = "friday-framework-tools"
+version = "0.1.0a0"
+description = "Comprehensive tool library for AI agents"
+readme = "README.md"
+requires-python = ">=3.10"
+license = "MIT"
+authors = [{ name = "Friday Team" }]
+keywords = ["ai", "agents", "tools", "llm", "automation"]
+
+dependencies = [
+    # Core protocols
+    "friday-framework-core==0.1.0a0",
+    # HTTP & Web
+    "httpx>=0.25.0",
+    "beautifulsoup4>=4.12.0",
+    "markdownify>=0.11.0",
+    "lxml>=4.9.0",
+    # Data formats
+    "pyyaml>=6.0.0",
+    "jsonpath-ng>=1.5.0",
+    # Text & Templates
+    "jinja2>=3.1.0",
+    # Git
+    "gitpython>=3.1.0",
+    # Math & Dates
+    "python-dateutil>=2.8.0",
+    "psutil>=7.2.1",
+    # Encoding detection
+    "charset-normalizer>=3.3.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/CIChuck/agent-framework"
+Repository = "https://github.com/CIChuck/agent-framework"
+Issues = "https://github.com/CIChuck/agent-framework/issues"
+Documentation = "https://github.com/CIChuck/agent-framework/tree/main/docs"
+Source = "https://github.com/CIChuck/agent-framework/tree/main/packages/friday-tools"
+
+[project.optional-dependencies]
+sandbox = [
+    "friday-framework-sandbox==0.1.0a0",
+]
+finance = [
+    "friday-framework-finance==0.1.0a0",
+]
+moltbook = [
+    "friday-framework-moltbook==0.1.0a0",
+]
+dev = [
+    "pytest>=8.0.0",
+    "pytest-asyncio>=0.23.0",
+    "respx>=0.20.0",
+    "pytest-mock>=3.10.0",
+]
+
+# Framework adapters (optional - import only when used)
+langchain = ["langchain-core>=0.1.0"]
+anthropic = ["anthropic>=0.25.0"]
+openai = ["openai>=1.0.0"]
+all-adapters = [
+    "friday-framework-tools[langchain]==0.1.0a0",
+    "friday-framework-tools[anthropic]==0.1.0a0",
+    "friday-framework-tools[openai]==0.1.0a0",
+]
+
+# Document format readers (optional)
+documents = [
+    "pypdf>=4.0",
+    "python-docx>=1.0",
+]
+
+# Spreadsheet readers (optional)
+spreadsheets = [
+    "openpyxl>=3.1",
+]
+
+# All file format support
+all-formats = [
+    "friday-framework-tools[documents]==0.1.0a0",
+    "friday-framework-tools[spreadsheets]==0.1.0a0",
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/friday_tools"]
+
+[tool.uv.sources]
+friday-framework-core = { workspace = true }
+friday-framework-sandbox = { workspace = true }
+friday-framework-moltbook = { workspace = true }
+friday-framework-finance = { workspace = true }
+
+[tool.pytest.ini_options]
+testpaths = ["tests_tools"]
+asyncio_mode = "auto"
+asyncio_default_fixture_loop_scope = "function"
+
+[tool.ruff]
+line-length = 88
+target-version = "py310"
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "UP", "B", "SIM"]

friday_framework_tools-0.1.0a0/src/friday_tools/__init__.py

@@ -0,0 +1,75 @@
+# mypy: ignore-errors
+"""
+Friday Tools - Comprehensive tool library for AI agents.
+
+This package provides a wide variety of tools for AI agents including
+filesystem operations, web access, data format handling, git operations,
+and more.
+
+Ref: docs/reference/specs/tool_specification.md
+"""
+
+from .base import FridayTool, ToolResult
+from .definition import BaseTool, FunctionTool, create_tool
+
+# Smart file reading
+from .filesystem.smart_read import SmartFileReadTool
+
+# Finance tools
+from .finance import (
+    GetCryptoDataTool,
+    GetMarketDataTool,
+    GetTechnicalAnalysisTool,
+    MassiveBaseTool,
+)
+from .manifest import ToolManifest
+from .protocols import ToolAdapter, ToolDefinition, ToolRegistry
+from .registry import DefaultToolRegistry, get_default_registry, tool
+from .sandbox import (
+    CommandSecurityError,
+    FilesystemSandbox,
+    PathSecurityError,
+    SecurityError,
+    ShellSandbox,
+)
+
+# Utility tools
+from .utility import EchoTool, GetCurrentDateTimeTool
+
+__all__ = [
+    # Protocols
+    "ToolDefinition",
+    "ToolAdapter",
+    "ToolRegistry",
+    # Base classes
+    "BaseTool",
+    "FunctionTool",
+    "FridayTool",
+    "ToolResult",
+    # Registry
+    "DefaultToolRegistry",
+    "get_default_registry",
+    # Manifest
+    "ToolManifest",
+    # Decorators
+    "tool",
+    "create_tool",
+    # Security
+    "FilesystemSandbox",
+    "ShellSandbox",
+    "SecurityError",
+    "PathSecurityError",
+    "CommandSecurityError",
+    # Utility tools
+    "GetCurrentDateTimeTool",
+    "EchoTool",
+    # Smart file reading
+    "SmartFileReadTool",
+    # Finance tools
+    "MassiveBaseTool",
+    "GetMarketDataTool",
+    "GetCryptoDataTool",
+    "GetTechnicalAnalysisTool",
+]
+
+__version__ = "0.1.0"

friday_framework_tools-0.1.0a0/src/friday_tools/adapters/__init__.py

@@ -0,0 +1,33 @@
+# mypy: ignore-errors
+"""
+Framework adapters for converting external tools to Friday format.
+
+Ref: docs/reference/specs/tool_specification.md - Section 6: Adapters
+
+These adapters allow tools from other frameworks (LangChain, Anthropic,
+OpenAI) to be used within the Friday framework.
+
+Optional Dependencies:
+    - langchain-core: For LangChainToolAdapter
+    - anthropic: For AnthropicToolAdapter
+    - openai: For OpenAIToolAdapter
+
+Example:
+    ```python
+    from friday_tools.adapters import LangChainToolAdapter
+    from langchain_community.tools import DuckDuckGoSearchRun
+
+    adapter = LangChainToolAdapter()
+    friday_tool = adapter.adapt(DuckDuckGoSearchRun())
+    ```
+"""
+
+from .anthropic import AnthropicToolAdapter
+from .langchain import LangChainToolAdapter
+from .openai import OpenAIToolAdapter
+
+__all__ = [
+    "LangChainToolAdapter",
+    "AnthropicToolAdapter",
+    "OpenAIToolAdapter",
+]

friday_framework_tools-0.1.0a0/src/friday_tools/adapters/anthropic.py

@@ -0,0 +1,190 @@
+# mypy: ignore-errors
+"""
+Anthropic tool adapter.
+
+Ref: docs/reference/specs/tool_specification.md - Section 6.2: Anthropic Adapter
+
+Converts Anthropic tool definitions (dict format) to Friday's ToolDefinition.
+"""
+
+from __future__ import annotations
+
+import logging
+from collections.abc import Callable
+from typing import Any
+
+from ..definition import BaseTool
+from ..protocols import ToolDefinition
+
+logger = logging.getLogger(__name__)
+
+
+class AnthropicToolWrapper(BaseTool):
+    """Wraps an Anthropic tool definition as a Friday tool."""
+
+    def __init__(
+        self,
+        tool_def: dict[str, Any],
+        handler: Callable[..., Any] | None = None,
+    ):
+        """
+        Initialize wrapper.
+
+        Args:
+            tool_def: Anthropic tool definition dict.
+            handler: Optional function to execute the tool.
+        """
+        self._tool_def = tool_def
+        self._handler = handler
+
+    @property
+    def name(self) -> str:
+        return self._tool_def["name"]
+
+    @property
+    def description(self) -> str:
+        return self._tool_def.get("description", f"Execute {self.name}")
+
+    @property
+    def parameters_schema(self) -> dict[str, Any]:
+        """Get input schema from Anthropic format."""
+        return self._tool_def.get(
+            "input_schema",
+            {
+                "type": "object",
+                "properties": {},
+            },
+        )
+
+    async def execute(self, **kwargs: Any) -> str:
+        """Execute the tool using the provided handler."""
+        if self._handler is None:
+            raise RuntimeError(
+                f"No handler provided for tool '{self.name}'. "
+                "Anthropic tools require a handler function."
+            )
+
+        import asyncio
+        import inspect
+
+        if inspect.iscoroutinefunction(self._handler):
+            result = await self._handler(**kwargs)
+        else:
+            loop = asyncio.get_event_loop()
+            result = await loop.run_in_executor(None, lambda: self._handler(**kwargs))
+
+        return str(result) if result is not None else ""
+
+
+class AnthropicToolAdapter:
+    """
+    Adapts Anthropic tool definitions to Friday ToolDefinition.
+
+    Anthropic tools are defined as dictionaries with the following format:
+    ```python
+    {
+        "name": "get_weather",
+        "description": "Get the current weather",
+        "input_schema": {
+            "type": "object",
+            "properties": {
+                "location": {"type": "string", "description": "City name"}
+            },
+            "required": ["location"]
+        }
+    }
+    ```
+
+    Example:
+        ```python
+        adapter = AnthropicToolAdapter()
+
+        anthropic_tool = {
+            "name": "calculator",
+            "description": "Evaluate math expressions",
+            "input_schema": {
+                "type": "object",
+                "properties": {
+                    "expression": {"type": "string"}
+                },
+                "required": ["expression"]
+            }
+        }
+
+        def calc_handler(expression: str) -> str:
+            return str(eval(expression))
+
+        friday_tool = adapter.adapt(anthropic_tool, handler=calc_handler)
+        ```
+    """
+
+    def adapt(
+        self,
+        external_tool: dict[str, Any],
+        handler: Callable[..., Any] | None = None,
+    ) -> ToolDefinition:
+        """
+        Convert an Anthropic tool definition to Friday's ToolDefinition.
+
+        Args:
+            external_tool: Anthropic tool definition dict.
+            handler: Function to execute when the tool is called.
+
+        Returns:
+            Friday ToolDefinition (actually an AnthropicToolWrapper).
+        """
+        self._validate_anthropic_tool(external_tool)
+        return AnthropicToolWrapper(external_tool, handler=handler)
+
+    def adapt_many(
+        self,
+        tools: list[dict[str, Any]],
+        handlers: dict[str, Callable[..., Any]] | None = None,
+    ) -> list[ToolDefinition]:
+        """
+        Convert multiple Anthropic tool definitions.
+
+        Args:
+            tools: List of Anthropic tool definition dicts.
+            handlers: Optional dict mapping tool names to handler functions.
+
+        Returns:
+            List of Friday ToolDefinition instances.
+        """
+        handlers = handlers or {}
+        return [self.adapt(tool, handler=handlers.get(tool["name"])) for tool in tools]
+
+    def _validate_anthropic_tool(self, tool: dict[str, Any]) -> None:
+        """Validate that the dict is a valid Anthropic tool definition."""
+        if not isinstance(tool, dict):
+            raise TypeError(
+                f"Expected dict for Anthropic tool, got {type(tool).__name__}"
+            )
+
+        if "name" not in tool:
+            raise ValueError("Anthropic tool must have 'name' field")
+
+    @staticmethod
+    def from_anthropic_response(
+        response_tools: list[dict[str, Any]],
+    ) -> list[dict[str, Any]]:
+        """
+        Extract tool definitions from an Anthropic API response.
+
+        This is useful when you want to re-use tools defined by
+        an Anthropic API response.
+
+        Args:
+            response_tools: List of tool dicts from Anthropic API.
+
+        Returns:
+            List of tool definitions in Anthropic format.
+        """
+        return [
+            {
+                "name": t["name"],
+                "description": t.get("description", ""),
+                "input_schema": t.get("input_schema", {}),
+            }
+            for t in response_tools
+        ]

friday_framework_tools-0.1.0a0/src/friday_tools/adapters/langchain.py

@@ -0,0 +1,145 @@
+# mypy: ignore-errors
+"""
+LangChain tool adapter.
+
+Ref: docs/reference/specs/tool_specification.md - Section 6.1: LangChain Adapter
+
+Converts LangChain BaseTool instances to Friday's ToolDefinition format.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+from typing import TYPE_CHECKING, Any
+
+from ..definition import BaseTool
+from ..protocols import ToolDefinition
+
+if TYPE_CHECKING:
+    from langchain_core.tools import BaseTool as LCBaseTool
+
+logger = logging.getLogger(__name__)
+
+
+class LangChainToolWrapper(BaseTool):
+    """Wraps a LangChain tool as a Friday tool."""
+
+    def __init__(self, lc_tool: LCBaseTool):
+        """
+        Initialize wrapper.
+
+        Args:
+            lc_tool: The LangChain tool to wrap.
+        """
+        self._lc_tool = lc_tool
+
+    @property
+    def name(self) -> str:
+        return self._lc_tool.name
+
+    @property
+    def description(self) -> str:
+        return self._lc_tool.description
+
+    @property
+    def parameters_schema(self) -> dict[str, Any]:
+        """Convert LangChain schema to JSON Schema."""
+        # LangChain tools have an args_schema (Pydantic model)
+        if hasattr(self._lc_tool, "args_schema") and self._lc_tool.args_schema:
+            return self._lc_tool.args_schema.model_json_schema()
+
+        # Fallback to simple string input
+        return {
+            "type": "object",
+            "properties": {
+                "input": {
+                    "type": "string",
+                    "description": "Input to the tool",
+                }
+            },
+            "required": ["input"],
+        }
+
+    async def execute(self, **kwargs: Any) -> str:
+        """Execute the LangChain tool."""
+        # LangChain tools can be sync or async
+        if hasattr(self._lc_tool, "arun"):
+            # Use async version if available
+            if len(kwargs) == 1 and "input" in kwargs:
+                result = await self._lc_tool.arun(kwargs["input"])
+            else:
+                result = await self._lc_tool.arun(**kwargs)
+        elif hasattr(self._lc_tool, "run"):
+            # Fall back to sync version
+            loop = asyncio.get_event_loop()
+            if len(kwargs) == 1 and "input" in kwargs:
+                result = await loop.run_in_executor(
+                    None, self._lc_tool.run, kwargs["input"]
+                )
+            else:
+                result = await loop.run_in_executor(
+                    None, lambda: self._lc_tool.run(**kwargs)
+                )
+        else:
+            raise RuntimeError("LangChain tool has no run or arun method")
+
+        return str(result) if result is not None else ""
+
+
+class LangChainToolAdapter:
+    """
+    Adapts LangChain BaseTool to Friday ToolDefinition.
+
+    Example:
+        ```python
+        from langchain_community.tools import DuckDuckGoSearchRun
+
+        adapter = LangChainToolAdapter()
+        ddg_tool = DuckDuckGoSearchRun()
+        friday_tool = adapter.adapt(ddg_tool)
+
+        # Now use with Friday
+        result = await friday_tool.execute(input="weather today")
+        ```
+    """
+
+    def adapt(self, external_tool: LCBaseTool) -> ToolDefinition:
+        """
+        Convert a LangChain tool to Friday's ToolDefinition.
+
+        Args:
+            external_tool: LangChain BaseTool instance.
+
+        Returns:
+            Friday ToolDefinition (actually a LangChainToolWrapper).
+        """
+        self._validate_langchain_tool(external_tool)
+        return LangChainToolWrapper(external_tool)
+
+    def adapt_many(self, tools: list[LCBaseTool]) -> list[ToolDefinition]:
+        """
+        Convert multiple LangChain tools.
+
+        Args:
+            tools: List of LangChain BaseTool instances.
+
+        Returns:
+            List of Friday ToolDefinition instances.
+        """
+        return [self.adapt(tool) for tool in tools]
+
+    def _validate_langchain_tool(self, tool: Any) -> None:
+        """Validate that the object is a LangChain tool."""
+        try:
+            from langchain_core.tools import BaseTool as LCBaseTool
+
+            if not isinstance(tool, LCBaseTool):
+                raise TypeError(
+                    f"Expected LangChain BaseTool, got {type(tool).__name__}"
+                )
+        except ImportError:
+            raise ImportError(  # noqa: B904
+                "langchain-core is required for LangChainToolAdapter. "
+                "Install with: pip install langchain-core"
+            )