friday-framework-finance 0.1.0a0__tar.gz

friday_framework_finance-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_finance-0.1.0a0/PKG-INFO

@@ -0,0 +1,45 @@
+Metadata-Version: 2.4
+Name: friday-framework-finance
+Version: 0.1.0a0
+Summary: Financial data provider integration for Friday Agent Framework
+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-finance
+Author: Friday Team
+License-Expression: MIT
+Requires-Python: >=3.10
+Requires-Dist: friday-framework-core==0.1.0a0
+Requires-Dist: massive
+Description-Content-Type: text/markdown
+
+# Friday Finance
+
+This package provides financial data integration for the Friday Agent Framework.
+
+## Install
+
+```bash
+pip install friday-framework-finance
+```
+
+## Import Package
+
+```python
+import friday_finance
+```
+
+## Providers
+
+### Massive (Massive Agent Core)
+A robust, asynchronous wrapper for the Massive API, designed for AI agents.
+
+- **Equities**: Stock data with market-day resolution.
+- **Crypto**: Real-time cryptocurrency snapshots.
+- **Indicators**: Technical analysis (SMA, RSI, Trend).
+- **Governor**: Tier-sensitive rate limiting.
+
+## License
+
+MIT

friday_framework_finance-0.1.0a0/README.md

@@ -0,0 +1,29 @@
+# Friday Finance
+
+This package provides financial data integration for the Friday Agent Framework.
+
+## Install
+
+```bash
+pip install friday-framework-finance
+```
+
+## Import Package
+
+```python
+import friday_finance
+```
+
+## Providers
+
+### Massive (Massive Agent Core)
+A robust, asynchronous wrapper for the Massive API, designed for AI agents.
+
+- **Equities**: Stock data with market-day resolution.
+- **Crypto**: Real-time cryptocurrency snapshots.
+- **Indicators**: Technical analysis (SMA, RSI, Trend).
+- **Governor**: Tier-sensitive rate limiting.
+
+## License
+
+MIT

friday_framework_finance-0.1.0a0/pyproject.toml

@@ -0,0 +1,32 @@
+[project]
+name = "friday-framework-finance"
+version = "0.1.0a0"
+description = "Financial data provider integration for Friday Agent Framework"
+readme = "README.md"
+requires-python = ">=3.10"
+license = "MIT"
+authors = [{ name = "Friday Team" }]
+dependencies = [
+    "massive",
+    "friday-framework-core==0.1.0a0",
+]
+
+[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-finance"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/friday_finance"]
+
+[project.scripts]
+friday-finance-demo = "friday_finance.demo:main"
+
+[tool.uv.sources]
+friday-framework-core = { workspace = true }

friday_framework_finance-0.1.0a0/src/friday_finance/__init__.py

@@ -0,0 +1,37 @@
+# mypy: ignore-errors
+"""
+Friday Finance - Financial data provider integration.
+
+This package provides data-access modules for financial APIs.
+Tool wrappers (BaseTool subclasses) live in ``friday_tools.finance``.
+"""
+
+from .providers.massive import (
+    AssetRegistry,
+    CryptoModule,
+    EquitiesModule,
+    IndicatorsModule,
+    MassiveAgentClient,
+    MassiveAuthError,
+    MassiveBaseException,
+    MassiveGovernor,
+    MassiveMarketClosedError,
+    MassiveNotFoundError,
+    MassiveRateLimitError,
+    MassiveTimeoutError,
+)
+
+__all__ = [
+    "MassiveAgentClient",
+    "MassiveGovernor",
+    "AssetRegistry",
+    "EquitiesModule",
+    "CryptoModule",
+    "IndicatorsModule",
+    "MassiveAuthError",
+    "MassiveBaseException",
+    "MassiveMarketClosedError",
+    "MassiveNotFoundError",
+    "MassiveRateLimitError",
+    "MassiveTimeoutError",
+]

friday_framework_finance-0.1.0a0/src/friday_finance/demo.py

@@ -0,0 +1,129 @@
+# mypy: ignore-errors
+import asyncio
+import json
+import os
+import time
+from collections.abc import Coroutine
+from typing import Any
+
+from friday_finance import MassiveAgentClient
+
+# ANSI Colors for nicer CLI output
+CYAN = "\033[96m"
+GREEN = "\033[92m"
+YELLOW = "\033[93m"
+RED = "\033[91m"
+RESET = "\033[0m"
+BOLD = "\033[1m"
+
+
+def print_header(title: str):
+    print(f"\n{BOLD}{CYAN}=== {title} ==={RESET}")
+
+
+def print_result(label: str, data: Any):
+    if isinstance(data, (dict, list)):
+        formatted = json.dumps(data, indent=2, default=str)
+        print(f"{GREEN}{label}:{RESET}\n{formatted}")
+    else:
+        print(f"{GREEN}{label}:{RESET} {data}")
+
+
+def print_error(label: str, error: Exception):
+    print(f"{RED}{label} FAILED:{RESET} {error}")
+
+
+async def run_step(name: str, coro: Coroutine):
+    print(f"\n{YELLOW}Running: {name}...{RESET}")
+    start = time.time()
+    try:
+        result = await coro
+        elapsed = time.time() - start
+        print_result(f"Result ({elapsed:.2f}s)", result)
+    except Exception as e:
+        print_error(name, e)
+
+
+async def async_main():
+    print_header("Friday Finance - Massive Provider Reference App")
+
+    # 1. Setup & Auth
+    api_key = os.getenv("MASSIVE_API_KEY")
+    if not api_key:
+        print(f"{RED}Error: MASSIVE_API_KEY environment variable is not set.{RESET}")
+        print("Please export it and try again:")
+        print("  export MASSIVE_API_KEY='your_key_here'")
+        return
+
+    # Check for tier override
+    tier = os.getenv("MASSIVE_TIER", "free")
+    print(f"Initializing Client (Tier: {BOLD}{tier}{RESET})...")
+
+    try:
+        client = MassiveAgentClient(api_key=api_key, tier=tier)
+    except Exception as e:
+        print_error("Initialization", e)
+        return
+
+    # 2. Equities Module Tests
+    print_header("Testing Equities Module")
+
+    # A. Company Details
+    await run_step("get_details('AAPL')", client.equities.get_details("AAPL"))
+
+    # B. EOD Price
+    await run_step("get_eod_price('MSFT')", client.equities.get_eod_price("MSFT"))
+
+    # C. Market Summary (Combines Details + Price)
+    await run_step(
+        "get_market_summary('NVDA')", client.equities.get_market_summary("NVDA")
+    )
+
+    # D. ETF Proxy Lookup (Registry Test)
+    print(f"\n{YELLOW}Testing Registry Lookup (sp500 -> SPY)...{RESET}")
+    await run_step("get_eod_price('sp500')", client.equities.get_eod_price("sp500"))
+
+    # 3. Crypto Module Tests
+    print_header("Testing Crypto Module (24/7)")
+
+    # A. Snapshot
+    await run_step("get_snapshot('BTC')", client.crypto.get_snapshot("BTC"))
+
+    # B. Risk On/Off Comparison
+    await run_step(
+        "get_risk_on_comparison() [BTC vs AGG]", client.crypto.get_risk_on_comparison()
+    )
+
+    # 4. Indicators Module Tests
+    print_header("Testing Indicators Module")
+
+    # A. SMA (Simple Moving Average)
+    await run_step(
+        "get_sma('SPY', window=50)", client.indicators.get_sma("SPY", window=50)
+    )
+
+    # B. RSI (Relative Strength Index)
+    await run_step(
+        "get_rsi('SPY', window=14)", client.indicators.get_rsi("SPY", window=14)
+    )
+
+    # C. Trend Analysis (Golden Cross Check)
+    # Note: This makes 2 calls (SMA50 + SMA200).
+    # On Free tier, this will demonstrate the Governor waiting 12s between calls.
+    print(f"\n{YELLOW}Testing Trend Analysis (Expect delays on Free Tier)...{RESET}")
+    await run_step(
+        "get_trend_analysis('SPY')", client.indicators.get_trend_analysis("SPY")
+    )
+
+    print_header("Test Complete")
+
+
+def main():
+    try:
+        asyncio.run(async_main())
+    except KeyboardInterrupt:
+        print(f"\n{RED}Test interrupted by user.{RESET}")
+
+
+if __name__ == "__main__":
+    main()

friday_framework_finance-0.1.0a0/src/friday_finance/providers/__init__.py

@@ -0,0 +1,2 @@
+# mypy: ignore-errors
+# Friday Finance Providers

friday_framework_finance-0.1.0a0/src/friday_finance/providers/massive/__init__.py

@@ -0,0 +1,30 @@
+# mypy: ignore-errors
+from .client import MassiveAgentClient
+from .exceptions import (
+    MassiveAuthError,
+    MassiveBaseException,
+    MassiveMarketClosedError,
+    MassiveNotFoundError,
+    MassiveRateLimitError,
+    MassiveTimeoutError,
+)
+from .governor import MassiveGovernor
+from .modules.crypto import CryptoModule
+from .modules.equities import EquitiesModule
+from .modules.indicators import IndicatorsModule
+from .registry import AssetRegistry
+
+__all__ = [
+    "MassiveAgentClient",
+    "MassiveGovernor",
+    "AssetRegistry",
+    "MassiveAuthError",
+    "MassiveBaseException",
+    "MassiveMarketClosedError",
+    "MassiveNotFoundError",
+    "MassiveRateLimitError",
+    "MassiveTimeoutError",
+    "EquitiesModule",
+    "CryptoModule",
+    "IndicatorsModule",
+]

friday_framework_finance-0.1.0a0/src/friday_finance/providers/massive/client.py

@@ -0,0 +1,109 @@
+# mypy: ignore-errors
+import asyncio
+import os
+
+from friday_core.logging import get_logger
+
+try:
+    from massive import RESTClient
+except ImportError:
+    # Placeholder for development if the SDK is not installed
+    class RESTClient:
+        """Stub RESTClient for development without the Massive SDK installed."""
+
+        def __init__(self, api_key):
+            pass
+
+
+from .exceptions import MassiveAuthError, MassiveRateLimitError
+from .governor import MassiveGovernor
+from .modules.crypto import CryptoModule
+from .modules.equities import EquitiesModule
+from .modules.indicators import IndicatorsModule
+
+logger = get_logger(__name__)
+
+
+class MassiveAgentClient:
+    """
+    Main entry point for the Massive Agent Core.
+
+    Orchestrates modules (Equities, Crypto, Indicators) and manages
+    the async Governor for tier-aware rate limiting. All SDK calls
+    should go through ``execute_query`` to respect rate limits.
+    """
+
+    def __init__(self, api_key: str = None, tier: str = "free"):
+        """
+        Initialise the Massive Agent client.
+
+        Args:
+            api_key: Massive API key. Falls back to the ``MASSIVE_API_KEY``
+                     environment variable when *None*.
+            tier: API tier — ``"free"`` (5 req/min) or ``"starter"``.
+
+        Raises:
+            MassiveAuthError: If no API key is provided or found in the
+                              environment.
+        """
+        self.api_key = api_key or os.getenv("MASSIVE_API_KEY")
+        if not self.api_key:
+            raise MassiveAuthError(
+                "API key is missing. Provide it or set the MASSIVE_API_KEY environment variable."  # noqa: E501
+            )
+
+        self.tier = tier
+        self.sdk = RESTClient(self.api_key)
+        self.governor = MassiveGovernor(tier=self.tier)
+
+        # Initialize Modules
+        self.equities = EquitiesModule(self)
+        self.crypto = CryptoModule(self)
+        self.indicators = IndicatorsModule(self)
+
+        logger.info(
+            "MassiveAgentClient initialised",
+            tier=self.tier,
+        )
+
+    async def probe_tier(self):
+        """
+        Automatically detect the API tier from response headers.
+
+        Not yet implemented — the client relies on the *tier* constructor
+        parameter for now.
+        """
+        # For now, we rely on the manual 'tier' parameter
+        pass
+
+    async def execute_query(self, func, *args, **kwargs):
+        """
+        Execute an SDK call through the Governor rate limiter.
+
+        Synchronous SDK functions are dispatched to a thread-pool executor
+        so the async event loop is never blocked.
+
+        Args:
+            func: The SDK callable to invoke.
+            *args: Positional arguments forwarded to *func*.
+            **kwargs: Keyword arguments forwarded to *func*.
+
+        Returns:
+            The raw result from the SDK call.
+
+        Raises:
+            MassiveRateLimitError: If the API returns HTTP 429 despite the
+                                   governor.
+        """
+        await self.governor.wait()
+        try:
+            loop = asyncio.get_running_loop()
+            result = await loop.run_in_executor(None, lambda: func(*args, **kwargs))
+            logger.debug("SDK query succeeded", func=func.__name__)
+            return result
+        except Exception as e:
+            if "429" in str(e):
+                logger.error("Rate limit hit despite governor", func=func.__name__)
+                raise MassiveRateLimitError("Rate limit hit despite governor.") from e
+            logger.error("SDK query failed", func=func.__name__, error=str(e))
+            raise

friday_framework_finance-0.1.0a0/src/friday_finance/providers/massive/exceptions.py

@@ -0,0 +1,37 @@
+# mypy: ignore-errors
+class MassiveBaseException(Exception):
+    """Base exception for all massive-agent-core errors."""
+
+    pass
+
+
+class MassiveAuthError(MassiveBaseException):
+    """Raised when the API Key is invalid or missing."""
+
+    pass
+
+
+class MassiveRateLimitError(MassiveBaseException):
+    """Raised when the 5 calls/minute limit is exceeded."""
+
+    def __init__(self, message="Rate limit exceeded. Wait 60 seconds.", retry_after=60):
+        super().__init__(message)
+        self.retry_after = retry_after
+
+
+class MassiveMarketClosedError(MassiveBaseException):
+    """Raised when data is requested for a time the market was closed."""
+
+    pass
+
+
+class MassiveNotFoundError(MassiveBaseException):
+    """Raised when a ticker or indicator is not found."""
+
+    pass
+
+
+class MassiveTimeoutError(MassiveBaseException):
+    """Raised when a query exceeds the defined timeout."""
+
+    pass

friday_framework_finance-0.1.0a0/src/friday_finance/providers/massive/governor.py

@@ -0,0 +1,56 @@
+# mypy: ignore-errors
+import asyncio
+
+from friday_core.logging import get_logger
+
+logger = get_logger(__name__)
+
+
+class MassiveGovernor:
+    """
+    A tier-aware rate limiter using a modified Token Bucket algorithm.
+
+    Enforces a minimum interval between successive API calls so that
+    the Massive free-tier limit (5 requests / minute) is never exceeded.
+    """
+
+    TIER_INTERVALS = {
+        "free": 12.05,  # 5 per minute ≈ 12 s spacing
+        "starter": 0.05,  # Effectively unlimited
+    }
+
+    def __init__(self, tier: str = "free"):
+        """
+        Initialise the governor.
+
+        Args:
+            tier: API tier — ``"free"`` or ``"starter"``.
+        """
+        self.tier = tier.lower()
+        self.interval = self.TIER_INTERVALS.get(self.tier, 12.05)
+        self.last_call = 0.0
+        self.lock = asyncio.Lock()
+
+    async def wait(self):
+        """Ensure the next call respects the tier's time boundary."""
+        async with self.lock:
+            now = asyncio.get_running_loop().time()
+            elapsed = now - self.last_call
+
+            if elapsed < self.interval:
+                sleep_time = self.interval - elapsed
+                logger.debug("Governor throttling", sleep_seconds=round(sleep_time, 2))
+                await asyncio.sleep(sleep_time)
+
+            self.last_call = asyncio.get_running_loop().time()
+
+    def update_tier(self, tier: str):
+        """
+        Switch to a different API tier at runtime.
+
+        Args:
+            tier: The new tier name (``"free"`` or ``"starter"``).
+        """
+        self.tier = tier.lower()
+        self.interval = self.TIER_INTERVALS.get(self.tier, 12.05)
+        logger.info("Governor tier updated", tier=self.tier, interval=self.interval)

friday_framework_finance-0.1.0a0/src/friday_finance/providers/massive/modules/__init__.py

@@ -0,0 +1,6 @@
+# mypy: ignore-errors
+from .crypto import CryptoModule
+from .equities import EquitiesModule
+from .indicators import IndicatorsModule
+
+__all__ = ["EquitiesModule", "CryptoModule", "IndicatorsModule"]

friday_framework_finance-0.1.0a0/src/friday_finance/providers/massive/modules/crypto.py

@@ -0,0 +1,136 @@
+# mypy: ignore-errors
+from datetime import datetime
+from typing import Any
+
+from friday_core.logging import get_logger
+
+from ..registry import AssetRegistry
+
+logger = get_logger(__name__)
+
+
+class CryptoModule:
+    """
+    Handles Cryptocurrency pairs (e.g., BTC/USD, ETH/USD).
+
+    Crypto markets are 24/7 so there is no Market Day logic; the most
+    recent previous-close aggregate is used to stay free-tier compatible.
+    """
+
+    def __init__(self, client):
+        """
+        Initialise the crypto module.
+
+        Args:
+            client: A ``MassiveAgentClient`` instance used for SDK calls.
+        """
+        self.client = client
+
+    def _format_ticker(self, symbol: str) -> str:
+        """
+        Standardise a symbol to the Massive ``X:BTCUSD`` format.
+
+        Args:
+            symbol: Raw symbol string (e.g. ``"BTC"``, ``"BTC/USD"``,
+                    ``"X:BTCUSD"``).
+
+        Returns:
+            The normalised ticker string.
+        """
+        symbol = symbol.upper().replace("/", "")
+        if not symbol.startswith("X:"):
+            if "USD" not in symbol:
+                symbol += "USD"
+            return f"X:{symbol}"
+        return symbol
+
+    async def get_snapshot(self, symbol: str) -> dict[str, Any]:
+        """
+        Get the most recent daily close (Previous Close) for a crypto pair.
+
+        Uses ``get_previous_close_agg`` to ensure compatibility with the
+        free tier.
+
+        Args:
+            symbol: Crypto symbol (e.g. ``"BTC"``, ``"ETH"``).
+
+        Returns:
+            A dict with ``symbol``, ``price``, ``day_change``,
+            ``day_change_percent``, and ``last_updated``.
+
+        Raises:
+            MassiveNotFoundError: When no data is returned for the symbol.
+        """
+        ticker = self._format_ticker(symbol)
+        logger.info("Fetching crypto snapshot", ticker=ticker)
+
+        func = self.client.sdk.get_previous_close_agg
+        result = await self.client.execute_query(func, ticker)
+
+        if not result or len(result) == 0:
+            logger.warning("No crypto data returned", ticker=ticker)
+            return {"symbol": ticker, "error": "No data found."}
+
+        last_bar = result[0]
+
+        change_percent = 0.0
+        if last_bar.open and last_bar.open != 0:
+            change_percent = ((last_bar.close - last_bar.open) / last_bar.open) * 100
+
+        return {
+            "symbol": ticker,
+            "price": last_bar.close,
+            "day_change": last_bar.close - last_bar.open,
+            "day_change_percent": round(change_percent, 2),
+            "last_updated": (
+                datetime.fromtimestamp(last_bar.timestamp / 1000).isoformat()
+                if hasattr(last_bar, "timestamp")
+                else datetime.now().isoformat()
+            ),
+            "note": "Data is Previous Close (Free Tier compatible)",
+        }
+
+    async def get_risk_on_comparison(self) -> dict[str, Any]:
+        """
+        Compare Bitcoin vs Bonds for a Risk-On / Risk-Off signal.
+
+        Fetches the latest BTC snapshot and the latest bond (AGG) EOD
+        price so the agent can assess relative momentum.
+
+        Returns:
+            A dict with ``risk_on_proxy`` (BTC data) and
+            ``risk_off_proxy`` (AGG bond data).
+        """
+        btc = await self.get_snapshot("BTC")
+
+        bond_ticker = AssetRegistry.resolve_ticker("total_bond")  # AGG
+        logger.info("Fetching bond data for risk comparison", ticker=bond_ticker)
+
+        # Fetch actual bond price data for a meaningful comparison
+        bond_result = await self.client.equities.get_eod_price(bond_ticker)
+
+        bond_proxy: dict[str, Any] = {
+            "asset": "AGG (Bonds)",
+            "ticker": bond_ticker,
+        }
+        if "error" not in bond_result:
+            bond_proxy.update(
+                {
+                    "price": bond_result["close"],
+                    "date": bond_result["date"],
+                }
+            )
+        else:
+            logger.warning(
+                "Bond data unavailable for risk comparison", error=bond_result["error"]
+            )
+            bond_proxy["error"] = bond_result["error"]
+
+        return {
+            "risk_on_proxy": {
+                "asset": "Bitcoin",
+                "price": btc.get("price"),
+                "change": btc.get("day_change_percent"),
+            },
+            "risk_off_proxy": bond_proxy,
+        }

friday_framework_finance-0.1.0a0/src/friday_finance/providers/massive/modules/equities.py

@@ -0,0 +1,134 @@
+# mypy: ignore-errors
+from datetime import datetime, timedelta
+from typing import Any
+
+from friday_core.logging import get_logger
+
+from ..registry import AssetRegistry
+
+logger = get_logger(__name__)
+
+
+class EquitiesModule:
+    """
+    Handles Stock and Index-proxy data fetching.
+
+    Includes 'Market Day' logic so free-tier queries always target a
+    valid trading day with available data.
+    """
+
+    def __init__(self, client):
+        """
+        Initialise the equities module.
+
+        Args:
+            client: A ``MassiveAgentClient`` instance used for SDK calls.
+        """
+        self.client = client
+
+    def _resolve_market_day(self, target_date: datetime = None) -> str:
+        """
+        Ensure we are querying a valid trading day.
+
+        If *target_date* falls on a weekend it is rolled back to the
+        previous Friday. Defaults to T-1 (yesterday) to guarantee data
+        availability on the free tier.
+
+        Args:
+            target_date: The desired date.  Defaults to yesterday.
+
+        Returns:
+            An ISO-formatted date string (``YYYY-MM-DD``).
+        """
+        if target_date is None:
+            # Default to yesterday to avoid "restricted timeframe" errors on Free Tier
+            target_date = datetime.now() - timedelta(days=1)
+
+        # Simplistic business day roll-back
+        while target_date.weekday() > 4:  # Saturday or Sunday
+            target_date -= timedelta(days=1)
+
+        return target_date.strftime("%Y-%m-%d")
+
+    async def get_details(self, ticker: str) -> dict[str, Any]:
+        """
+        Fetch company / ETF background information.
+
+        Args:
+            ticker: Symbol or alias (e.g. ``"AAPL"``, ``"sp500"``).
+
+        Returns:
+            A dict with keys ``ticker``, ``name``, ``description``,
+            ``homepage``, and ``market_cap``.
+        """
+        ticker = AssetRegistry.resolve_ticker(ticker)
+        logger.info("Fetching ticker details", ticker=ticker)
+
+        func = self.client.sdk.get_ticker_details
+        result = await self.client.execute_query(func, ticker)
+
+        return {
+            "ticker": result.ticker,
+            "name": result.name,
+            "description": getattr(result, "description", "No description available."),
+            "homepage": getattr(result, "homepage_url", ""),
+            "market_cap": getattr(result, "market_cap", None),
+        }
+
+    async def get_eod_price(self, ticker: str) -> dict[str, Any]:
+        """
+        Fetch the most recent daily close (End-of-Day) OHLCV bar.
+
+        Args:
+            ticker: Symbol or alias.
+
+        Returns:
+            A dict with ``ticker``, ``date``, ``open``, ``high``,
+            ``low``, ``close``, and ``volume``.
+        """
+        ticker = AssetRegistry.resolve_ticker(ticker)
+        market_day = self._resolve_market_day()
+        logger.info("Fetching EOD price", ticker=ticker, market_day=market_day)
+
+        func = self.client.sdk.get_aggs
+
+        result = await self.client.execute_query(
+            func, ticker, 1, "day", market_day, market_day
+        )
+
+        if not result or len(result) == 0:
+            return {"error": "No data found for the resolved market day."}
+
+        last_bar = result[0]
+        return {
+            "ticker": ticker,
+            "date": market_day,
+            "open": last_bar.open,
+            "high": last_bar.high,
+            "low": last_bar.low,
+            "close": last_bar.close,
+            "volume": last_bar.volume,
+        }
+
+    async def get_market_summary(self, ticker: str) -> dict[str, Any]:
+        """
+        High-level tool call for agents.
+
+        Combines identity details and price data into a single summary.
+        On the free tier the Governor will space the two underlying calls.
+
+        Args:
+            ticker: Symbol or alias.
+
+        Returns:
+            A dict with ``summary`` (human-readable string), ``details``,
+            and ``price_data``.
+        """
+        details = await self.get_details(ticker)
+        price = await self.get_eod_price(ticker)
+
+        return {
+            "summary": f"{details['name']} is trading at ${price['close']} as of {price['date']}.",  # noqa: E501
+            "details": details,
+            "price_data": price,
+        }

friday_framework_finance-0.1.0a0/src/friday_finance/providers/massive/modules/indicators.py

@@ -0,0 +1,143 @@
+# mypy: ignore-errors
+from typing import Any
+
+from friday_core.logging import get_logger
+
+from ..registry import AssetRegistry
+
+logger = get_logger(__name__)
+
+
+class IndicatorsModule:
+    """
+    Interface to Massive's Technical Indicators API.
+
+    Supports Simple Moving Average (SMA), Relative Strength Index (RSI),
+    and trend analysis via Golden / Death Cross detection.
+    """
+
+    def __init__(self, client):
+        """
+        Initialise the indicators module.
+
+        Args:
+            client: A ``MassiveAgentClient`` instance used for SDK calls.
+        """
+        self.client = client
+
+    async def get_sma(
+        self, ticker: str, window: int = 50, timespan: str = "day"
+    ) -> dict[str, Any]:
+        """
+        Fetch the Simple Moving Average for a ticker.
+
+        Common windows: 50 (intermediate trend), 200 (long-term trend).
+
+        Args:
+            ticker: Symbol or alias.
+            window: Number of periods for the moving average.
+            timespan: Bar size — ``"day"``, ``"week"``, etc.
+
+        Returns:
+            A dict with ``ticker``, ``window``, ``value``, ``timestamp``,
+            and ``indicator``.
+        """
+        ticker = AssetRegistry.resolve_ticker(ticker)
+        logger.info("Fetching SMA", ticker=ticker, window=window, timespan=timespan)
+
+        func = self.client.sdk.get_sma
+        result = await self.client.execute_query(
+            func,
+            ticker,
+            timestamp=None,  # Gets most recent
+            timespan=timespan,
+            window=window,
+            series_type="close",
+            order="desc",
+            limit=1,
+        )
+
+        if not result or not hasattr(result, "values") or len(result.values) == 0:
+            logger.warning("No SMA data returned", ticker=ticker, window=window)
+            return {
+                "ticker": ticker,
+                "window": window,
+                "value": None,
+                "status": "no_data",
+            }
+
+        latest_value = result.values[0].value
+        return {
+            "ticker": ticker,
+            "window": window,
+            "value": round(latest_value, 2),
+            "timestamp": result.values[0].timestamp,
+            "indicator": "SMA",
+        }
+
+    async def get_rsi(self, ticker: str, window: int = 14) -> dict[str, Any]:
+        """
+        Fetch the Relative Strength Index (momentum indicator).
+
+        The standard RSI window is 14 periods.
+
+        Args:
+            ticker: Symbol or alias.
+            window: Number of periods (default 14).
+
+        Returns:
+            A dict with ``ticker``, ``window``, ``value``, and
+            ``indicator``.
+        """
+        ticker = AssetRegistry.resolve_ticker(ticker)
+        logger.info("Fetching RSI", ticker=ticker, window=window)
+
+        func = self.client.sdk.get_rsi
+        result = await self.client.execute_query(
+            func,
+            ticker,
+            timespan="day",
+            window=window,
+            series_type="close",
+            order="desc",
+            limit=1,
+        )
+
+        latest_value = (
+            result.values[0].value if result and hasattr(result, "values") else None
+        )
+        return {
+            "ticker": ticker,
+            "window": window,
+            "value": round(latest_value, 2) if latest_value else None,
+            "indicator": "RSI",
+        }
+
+    async def get_trend_analysis(self, ticker: str) -> dict[str, Any]:
+        """
+        Determine Golden Cross / Death Cross status.
+
+        Compares SMA-50 against SMA-200.  Requires two API calls (spaced
+        by ~12 s on the free tier).
+
+        Args:
+            ticker: Symbol or alias.
+
+        Returns:
+            A dict with ``ticker``, ``sma50``, ``sma200``, and
+            ``sentiment`` (``"bullish"``, ``"bearish"``, or ``"neutral"``).
+        """
+        logger.info("Running trend analysis", ticker=ticker)
+        sma50 = await self.get_sma(ticker, 50)
+        sma200 = await self.get_sma(ticker, 200)
+
+        status = "neutral"
+        if sma50["value"] and sma200["value"]:
+            status = "bullish" if sma50["value"] > sma200["value"] else "bearish"
+
+        return {
+            "ticker": ticker,
+            "sma50": sma50["value"],
+            "sma200": sma200["value"],
+            "sentiment": status,
+        }

friday_framework_finance-0.1.0a0/src/friday_finance/providers/massive/registry.py

@@ -0,0 +1,43 @@
+# mypy: ignore-errors
+class AssetRegistry:
+    """
+    Manages the translation of human-readable concepts into Massive-compatible tickers.
+    Specifically designed to provide ETF proxies for Indices and Bonds.
+    """
+
+    # Mapping of categories to their most liquid ETF proxy
+    PROXIES = {
+        # Indices
+        "sp500": {"ticker": "SPY", "name": "S&P 500 Index (via SPY)"},
+        "nasdaq100": {"ticker": "QQQ", "name": "Nasdaq-100 (via QQQ)"},
+        "dowjones": {"ticker": "DIA", "name": "Dow Jones Industrial Average (via DIA)"},
+        "russell2000": {"ticker": "IWM", "name": "Russell 2000 (via IWM)"},
+        # Bonds / Fixed Income
+        "total_bond": {"ticker": "AGG", "name": "U.S. Aggregate Bond Index"},
+        "treasury_long": {"ticker": "TLT", "name": "20+ Year Treasury Bond"},
+        "treasury_mid": {"ticker": "IEF", "name": "7-10 Year Treasury Bond"},
+        "treasury_short": {"ticker": "SHY", "name": "1-3 Year Treasury Bond"},
+        "corp_bond": {"ticker": "LQD", "name": "Investment Grade Corporate Bond"},
+        "high_yield": {"ticker": "HYG", "name": "High Yield Corporate Bond"},
+    }
+
+    @classmethod
+    def resolve_ticker(cls, query: str) -> str:
+        """
+        Translates a common name or alias into a ticker.
+        If it's already a ticker (4 characters or fewer), it returns it as-is.
+        """
+        query_clean = query.lower().replace(" ", "_")
+        if query_clean in cls.PROXIES:
+            return cls.PROXIES[query_clean]["ticker"]
+
+        # Fallback: Assume it's already a ticker
+        return query.upper()
+
+    @classmethod
+    def get_metadata(cls, ticker: str) -> dict | None:
+        """Returns internal registry metadata for a given ticker proxy."""
+        for _key, data in cls.PROXIES.items():
+            if data["ticker"] == ticker.upper():
+                return data
+        return None

friday_framework_finance-0.1.0a0/tests/test_basics.py

@@ -0,0 +1,103 @@
+# mypy: ignore-errors
+import time
+
+import pytest
+from friday_finance.providers.massive.client import MassiveAgentClient
+from friday_finance.providers.massive.exceptions import MassiveAuthError
+from friday_finance.providers.massive.governor import MassiveGovernor
+from friday_finance.providers.massive.registry import AssetRegistry
+
+# ---------------------------------------------------------------------------
+# Registry tests
+# ---------------------------------------------------------------------------
+
+
+def test_registry_resolution():
+    """Verify alias-to-ticker translation and passthrough."""
+    assert AssetRegistry.resolve_ticker("sp500") == "SPY"
+    assert AssetRegistry.resolve_ticker("AAPL") == "AAPL"
+    assert AssetRegistry.resolve_ticker("total bond") == "AGG"
+
+
+def test_registry_metadata():
+    """Verify metadata lookup for a resolved ticker."""
+    meta = AssetRegistry.get_metadata("SPY")
+    assert meta is not None
+    assert meta["ticker"] == "SPY"
+    assert "S&P 500" in meta["name"]
+
+
+def test_registry_metadata_unknown():
+    """Verify metadata returns None for unknown tickers."""
+    assert AssetRegistry.get_metadata("ZZZZZ") is None
+
+
+# ---------------------------------------------------------------------------
+# Governor tests
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_governor_free_tier():
+    """Free tier governor should enforce >= 12 s spacing between calls."""
+    gov = MassiveGovernor(tier="free")
+    assert gov.interval > 12
+
+    start = time.time()
+    await gov.wait()  # First call is instant
+    await gov.wait()  # Second call should wait
+    end = time.time()
+
+    assert (end - start) >= 12
+
+
+@pytest.mark.asyncio
+async def test_governor_starter_tier():
+    """Starter tier governor should impose near-zero wait."""
+    gov = MassiveGovernor(tier="starter")
+    assert gov.interval < 1
+
+    start = time.time()
+    await gov.wait()
+    await gov.wait()
+    end = time.time()
+
+    assert (end - start) < 1
+
+
+@pytest.mark.asyncio
+async def test_governor_update_tier():
+    """Updating tier should change the interval immediately."""
+    gov = MassiveGovernor(tier="free")
+    assert gov.interval > 12
+
+    gov.update_tier("starter")
+    assert gov.interval < 1
+    assert gov.tier == "starter"
+
+
+# ---------------------------------------------------------------------------
+# Client tests
+# ---------------------------------------------------------------------------
+
+
+def test_client_raises_on_missing_api_key(monkeypatch):
+    """Client must raise MassiveAuthError when no API key is available."""
+    monkeypatch.delenv("MASSIVE_API_KEY", raising=False)
+    with pytest.raises(MassiveAuthError):
+        MassiveAgentClient(api_key=None)
+
+
+def test_client_accepts_explicit_api_key(monkeypatch):
+    """Client should initialise successfully with an explicit key."""
+    monkeypatch.delenv("MASSIVE_API_KEY", raising=False)
+    client = MassiveAgentClient(api_key="test-key-123", tier="starter")
+    assert client.api_key == "test-key-123"
+    assert client.tier == "starter"
+
+
+def test_client_reads_env_api_key(monkeypatch):
+    """Client should fall back to MASSIVE_API_KEY env var."""
+    monkeypatch.setenv("MASSIVE_API_KEY", "env-key-456")
+    client = MassiveAgentClient()
+    assert client.api_key == "env-key-456"

friday_framework_finance-0.1.0a0/tests/test_integration_massive.py

@@ -0,0 +1,157 @@
+# mypy: ignore-errors
+"""
+Integration tests for the Massive API provider.
+
+These tests use a real API key and hit the live Massive API.
+They are rate-limited by the MassiveGovernor (~12 s between calls
+on the free tier), so individual tests may take a while.
+
+Run with:
+    pytest packages/friday-finance/tests/test_integration_massive.py -v -s
+"""
+
+import pytest
+from friday_finance import MassiveAgentClient
+
+# ---------------------------------------------------------------------------
+# Fixtures
+# ---------------------------------------------------------------------------
+
+API_KEY = "pQBVbd4spIQEVEfc5WRjAonQXwBl_grA"
+
+
+@pytest.fixture(scope="module")
+def client():
+    """
+    Create a module-scoped MassiveAgentClient.
+
+    Sharing one client across all tests ensures the Governor
+    rate-limiter is honoured correctly.
+    """
+    return MassiveAgentClient(api_key=API_KEY, tier="free")
+
+
+# ---------------------------------------------------------------------------
+# Equities
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_get_eod_price(client):
+    """Fetch EOD price for AAPL — should return a dict with close price."""
+    result = await client.equities.get_eod_price("AAPL")
+    assert isinstance(result, dict)
+    assert result["ticker"] == "AAPL"
+    assert "close" in result
+    assert isinstance(result["close"], (int, float))
+
+
+@pytest.mark.asyncio
+async def test_get_details(client):
+    """Fetch company details for AAPL — should include name and market_cap."""
+    result = await client.equities.get_details("AAPL")
+    assert isinstance(result, dict)
+    assert result["ticker"] == "AAPL"
+    assert "name" in result
+    assert "market_cap" in result
+
+
+@pytest.mark.asyncio
+async def test_get_market_summary(client):
+    """Market summary combines price + details for a ticker."""
+    result = await client.equities.get_market_summary("AAPL")
+    assert isinstance(result, dict)
+    assert "summary" in result
+    assert "details" in result
+    assert "price_data" in result
+    assert result["details"]["ticker"] == "AAPL"
+    assert "close" in result["price_data"]
+
+
+@pytest.mark.asyncio
+async def test_alias_resolution(client):
+    """Alias 'sp500' should resolve to SPY and return valid data."""
+    result = await client.equities.get_eod_price("sp500")
+    assert isinstance(result, dict)
+    assert result["ticker"] == "SPY"
+    assert "close" in result
+
+
+# ---------------------------------------------------------------------------
+# Crypto
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_get_crypto_snapshot(client):
+    """Fetch a BTC snapshot — should include price and day_change fields."""
+    result = await client.crypto.get_snapshot("BTC")
+    assert isinstance(result, dict)
+    assert "price" in result
+    assert "day_change" in result
+    assert "day_change_percent" in result
+
+
+# ---------------------------------------------------------------------------
+# Technical Indicators
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_get_sma(client):
+    """Fetch SMA-50 for SPY — should return a numeric value."""
+    result = await client.indicators.get_sma("SPY", window=50)
+    assert isinstance(result, dict)
+    assert result["indicator"] == "SMA"
+    assert result["window"] == 50
+    assert result["value"] is not None
+    assert isinstance(result["value"], (int, float))
+
+
+@pytest.mark.asyncio
+async def test_get_rsi(client):
+    """Fetch RSI-14 for AAPL — value should be between 0 and 100."""
+    result = await client.indicators.get_rsi("AAPL", window=14)
+    assert isinstance(result, dict)
+    assert result["indicator"] == "RSI"
+    assert result["value"] is not None
+    assert 0 <= result["value"] <= 100
+
+
+# ---------------------------------------------------------------------------
+# Tool wrappers (via friday_tools.finance)
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.asyncio
+async def test_market_data_tool(client):
+    """GetMarketDataTool should return a string result via execute()."""
+    from friday_tools.finance import GetMarketDataTool
+
+    tool = GetMarketDataTool(client=client)
+    result = await tool.execute(ticker="AAPL", data_type="price")
+    assert isinstance(result, str)
+    assert "AAPL" in result
+    assert "close" in result
+
+
+@pytest.mark.asyncio
+async def test_crypto_data_tool(client):
+    """GetCryptoDataTool should return a string result via execute()."""
+    from friday_tools.finance import GetCryptoDataTool
+
+    tool = GetCryptoDataTool(client=client)
+    result = await tool.execute(symbol="BTC")
+    assert isinstance(result, str)
+    assert "price" in result
+
+
+@pytest.mark.asyncio
+async def test_technical_analysis_tool(client):
+    """GetTechnicalAnalysisTool should return SMA data as a string."""
+    from friday_tools.finance import GetTechnicalAnalysisTool
+
+    tool = GetTechnicalAnalysisTool(client=client)
+    result = await tool.execute(ticker="SPY", indicator="sma", window=50)
+    assert isinstance(result, str)
+    assert "SMA" in result