fahali 0.1.0__tar.gz

fahali-0.1.0/PKG-INFO

@@ -0,0 +1,117 @@
+Metadata-Version: 2.4
+Name: fahali
+Version: 0.1.0
+Summary: Market intelligence AI agents can verify - signed receipts, judged track record (misses included), Brier-calibrated forecasts. Adapters for LangChain, CrewAI, LlamaIndex, AutoGen, smolagents. MCP: mcp.fahaliai.com
+Project-URL: Homepage, https://fahaliai.com/developer
+Project-URL: Documentation, https://fahaliai.com/developer
+Project-URL: Repository, https://github.com/BobMain-2025/fahali-integrations
+Author-email: Future Legends AI <robert@futurelegendsai.com>
+License-Expression: MIT
+Keywords: ai-agents,crewai,crypto,function-calling,langchain,llamaindex,market-intelligence,mcp,risk
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Office/Business :: Financial :: Investment
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# fahali
+
+**Market intelligence AI agents can verify.** Every verdict carries a signed SHA-256 receipt. Every judged signal has a public replay URL. The track record keeps its misses and publishes its methodology. Forecast probabilities are Brier-scored against realized outcomes.
+
+Zero dependencies. Works with any agent framework. *Observation, not advice.*
+
+```bash
+pip install fahali    # Python
+npm install fahali    # JS/TS
+```
+
+Free key (50 calls/day, no card): [app.fahaliai.com/developer](https://app.fahaliai.com/developer) · Docs: [fahaliai.com/developer](https://fahaliai.com/developer) · MCP: `https://mcp.fahaliai.com/mcp`
+
+## Direct
+
+```ts
+import { FahaliClient } from "fahali";
+
+const fahali = new FahaliClient({ apiKey: process.env.FAHALI_API_KEY });
+const verdict = await fahali.verdict(["BTCUSDT"]);   // committee read + signed receipt
+const record  = await fahali.symbolRecord("BTCUSDT"); // judged record, misses included
+```
+
+## OpenAI (and anything using function-calling format)
+
+```ts
+import { FahaliClient, FAHALI_TOOLS, executeTool } from "fahali";
+
+const fahali = new FahaliClient({ apiKey: process.env.FAHALI_API_KEY });
+const tools = FAHALI_TOOLS.map((t) => ({ type: "function", function: t }));
+// ...pass `tools` to chat.completions.create; on a tool call:
+const result = await executeTool(fahali, call.function.name, JSON.parse(call.function.arguments));
+```
+
+## LangChain (Python)
+
+```python
+from fahali import FahaliClient
+from fahali.langchain import get_langchain_tools
+tools = get_langchain_tools(FahaliClient(api_key=...))
+```
+
+## CrewAI
+
+```python
+from fahali.crewai import get_crewai_tools
+```
+
+## LlamaIndex
+
+```python
+from fahali.llamaindex import get_llamaindex_tools
+```
+
+## AutoGen / smolagents / Semantic Kernel / raw OpenAI
+
+```python
+from fahali import FahaliClient, TOOL_SPECS, execute_tool  # function-calling format
+```
+
+## Vercel AI SDK
+
+```ts
+import { tool, jsonSchema, generateText } from "ai";
+import { FahaliClient, toAiSdkTools } from "fahali";
+
+const fahali = new FahaliClient({ apiKey: process.env.FAHALI_API_KEY });
+const { text } = await generateText({
+  model,
+  tools: toAiSdkTools(fahali, { tool, jsonSchema }),
+  prompt: "Is anything threatening a BTC-heavy portfolio right now? Cite replays.",
+});
+```
+
+## LangChain.js
+
+```ts
+import { DynamicStructuredTool } from "@langchain/core/tools";
+import { FahaliClient, toLangchainTools } from "fahali";
+
+const fahali = new FahaliClient({ apiKey: process.env.FAHALI_API_KEY });
+const tools = toLangchainTools(fahali, { DynamicStructuredTool });
+```
+
+## Tools
+
+| Tool | What your agent gets |
+|---|---|
+| `fahali_verdict` | 18-engine committee read: agreement, dissent on the record, signed receipt, replay URL |
+| `fahali_forecast_72h` | Crash/neutral/pump distribution, Brier-calibrated |
+| `fahali_tape` | Latest judged calls market-wide — hits **and misses** |
+| `fahali_symbol_record` | Per-symbol judged record with replay URLs |
+| `fahali_track_record` | Aggregate scorecard: lift vs base rate, sample sizes, disclosed gaps |
+| `fahali_recent_alerts` | Live detections across ~600 scanned instruments |
+
+## Why this instead of a terminal or search
+
+Terminals were built for human eyes; search gives agents unaccountable text. Fahali's answers are **claims your agent can check**: methodology at [fahaliai.com/methodology](https://fahaliai.com/methodology), pricing free → metered at [fahaliai.com/developer](https://fahaliai.com/developer).
+
+MIT © Future Legends AI. Nothing here is a recommendation to buy or sell anything.

fahali-0.1.0/README.md

@@ -0,0 +1,100 @@
+# fahali
+
+**Market intelligence AI agents can verify.** Every verdict carries a signed SHA-256 receipt. Every judged signal has a public replay URL. The track record keeps its misses and publishes its methodology. Forecast probabilities are Brier-scored against realized outcomes.
+
+Zero dependencies. Works with any agent framework. *Observation, not advice.*
+
+```bash
+pip install fahali    # Python
+npm install fahali    # JS/TS
+```
+
+Free key (50 calls/day, no card): [app.fahaliai.com/developer](https://app.fahaliai.com/developer) · Docs: [fahaliai.com/developer](https://fahaliai.com/developer) · MCP: `https://mcp.fahaliai.com/mcp`
+
+## Direct
+
+```ts
+import { FahaliClient } from "fahali";
+
+const fahali = new FahaliClient({ apiKey: process.env.FAHALI_API_KEY });
+const verdict = await fahali.verdict(["BTCUSDT"]);   // committee read + signed receipt
+const record  = await fahali.symbolRecord("BTCUSDT"); // judged record, misses included
+```
+
+## OpenAI (and anything using function-calling format)
+
+```ts
+import { FahaliClient, FAHALI_TOOLS, executeTool } from "fahali";
+
+const fahali = new FahaliClient({ apiKey: process.env.FAHALI_API_KEY });
+const tools = FAHALI_TOOLS.map((t) => ({ type: "function", function: t }));
+// ...pass `tools` to chat.completions.create; on a tool call:
+const result = await executeTool(fahali, call.function.name, JSON.parse(call.function.arguments));
+```
+
+## LangChain (Python)
+
+```python
+from fahali import FahaliClient
+from fahali.langchain import get_langchain_tools
+tools = get_langchain_tools(FahaliClient(api_key=...))
+```
+
+## CrewAI
+
+```python
+from fahali.crewai import get_crewai_tools
+```
+
+## LlamaIndex
+
+```python
+from fahali.llamaindex import get_llamaindex_tools
+```
+
+## AutoGen / smolagents / Semantic Kernel / raw OpenAI
+
+```python
+from fahali import FahaliClient, TOOL_SPECS, execute_tool  # function-calling format
+```
+
+## Vercel AI SDK
+
+```ts
+import { tool, jsonSchema, generateText } from "ai";
+import { FahaliClient, toAiSdkTools } from "fahali";
+
+const fahali = new FahaliClient({ apiKey: process.env.FAHALI_API_KEY });
+const { text } = await generateText({
+  model,
+  tools: toAiSdkTools(fahali, { tool, jsonSchema }),
+  prompt: "Is anything threatening a BTC-heavy portfolio right now? Cite replays.",
+});
+```
+
+## LangChain.js
+
+```ts
+import { DynamicStructuredTool } from "@langchain/core/tools";
+import { FahaliClient, toLangchainTools } from "fahali";
+
+const fahali = new FahaliClient({ apiKey: process.env.FAHALI_API_KEY });
+const tools = toLangchainTools(fahali, { DynamicStructuredTool });
+```
+
+## Tools
+
+| Tool | What your agent gets |
+|---|---|
+| `fahali_verdict` | 18-engine committee read: agreement, dissent on the record, signed receipt, replay URL |
+| `fahali_forecast_72h` | Crash/neutral/pump distribution, Brier-calibrated |
+| `fahali_tape` | Latest judged calls market-wide — hits **and misses** |
+| `fahali_symbol_record` | Per-symbol judged record with replay URLs |
+| `fahali_track_record` | Aggregate scorecard: lift vs base rate, sample sizes, disclosed gaps |
+| `fahali_recent_alerts` | Live detections across ~600 scanned instruments |
+
+## Why this instead of a terminal or search
+
+Terminals were built for human eyes; search gives agents unaccountable text. Fahali's answers are **claims your agent can check**: methodology at [fahaliai.com/methodology](https://fahaliai.com/methodology), pricing free → metered at [fahaliai.com/developer](https://fahaliai.com/developer).
+
+MIT © Future Legends AI. Nothing here is a recommendation to buy or sell anything.

fahali-0.1.0/fahali/__init__.py

@@ -0,0 +1,128 @@
+"""fahali — market intelligence AI agents can verify.
+
+Signed receipts on every verdict, a judged track record that keeps its
+misses, Brier-calibrated forecasts, public replays. Observation, not advice.
+
+Free key (50 calls/day): https://app.fahaliai.com/developer
+Adapters: fahali.langchain, fahali.crewai, fahali.llamaindex — plus
+TOOL_SPECS (OpenAI function-calling format) for AutoGen, smolagents,
+Semantic Kernel, or anything else.
+"""
+from __future__ import annotations
+
+import json
+import urllib.request
+import urllib.error
+from typing import Any, Optional
+
+__version__ = "0.1.0"
+DEFAULT_BASE_URL = "https://app.fahaliai.com"
+
+
+class FahaliError(RuntimeError):
+    pass
+
+
+class FahaliClient:
+    """Minimal, dependency-free client for the Fahali API."""
+
+    def __init__(self, api_key: Optional[str] = None, base_url: str = DEFAULT_BASE_URL, timeout: float = 20.0):
+        self.api_key = api_key
+        self.base_url = base_url.rstrip("/")
+        self.timeout = timeout
+
+    def _get(self, path: str) -> Any:
+        req = urllib.request.Request(self.base_url + path)
+        if self.api_key:
+            req.add_header("Authorization", f"Bearer {self.api_key}")
+        try:
+            with urllib.request.urlopen(req, timeout=self.timeout) as r:
+                return json.loads(r.read().decode("utf-8"))
+        except urllib.error.HTTPError as e:
+            body = e.read().decode("utf-8", "ignore")[:300]
+            raise FahaliError(f"Fahali {e.code} on {path}: {body}") from None
+
+    def verdict(self, symbols: list[str]) -> Any:
+        """Committee verdict(s) with signed receipts."""
+        return self._get(f"/api/agent/verdict?symbols={','.join(symbols)}")
+
+    def forecast_72h(self, symbol: str) -> Any:
+        """72h crash/neutral/pump forecast (Brier-calibrated distribution)."""
+        return self._get(f"/api/forecast/72h?symbol={symbol}")
+
+    def tape(self) -> Any:
+        """Latest judged calls market-wide — hits AND misses. Public."""
+        return self._get("/api/tape")
+
+    def replay(self, signal_id: str) -> Any:
+        """Public replay of one judged signal — citable proof."""
+        return self._get(f"/api/replay/{signal_id}")
+
+    def symbol_record(self, symbol: str) -> Any:
+        """Per-symbol judged record (last 9 calls, misses included). Public."""
+        return self._get(f"/api/replay/history/{symbol}")
+
+    def track_record(self) -> Any:
+        """Aggregate scorecard: lift vs base rates, samples, disclosed gaps."""
+        return self._get("/api/track-record/scorecard")
+
+    def recent_alerts(self) -> Any:
+        """Latest detections across the scanned universe."""
+        return self._get("/api/alerts/recent")
+
+    def public_stats(self) -> Any:
+        """Coverage + freshness. Public, no auth."""
+        return self._get("/api/public/stats")
+
+
+# OpenAI function-calling format — AutoGen, Semantic Kernel, raw OpenAI, etc.
+TOOL_SPECS: list[dict[str, Any]] = [
+    {
+        "name": "fahali_verdict",
+        "description": "Committee market verdict for symbols (e.g. BTCUSDT). 18 engines vote; includes agreement, dissent kept on the record, a signed SHA-256 receipt and a public replay URL. Observation, not advice.",
+        "parameters": {"type": "object", "properties": {"symbols": {"type": "array", "items": {"type": "string"}}}, "required": ["symbols"]},
+    },
+    {
+        "name": "fahali_forecast_72h",
+        "description": "72-hour crash/neutral/pump probability forecast for one symbol; the distribution is Brier-scored against realized outcomes.",
+        "parameters": {"type": "object", "properties": {"symbol": {"type": "string"}}, "required": ["symbol"]},
+    },
+    {
+        "name": "fahali_tape",
+        "description": "The live tape: latest judged calls across the market, hits AND misses, each with a public replay URL.",
+        "parameters": {"type": "object", "properties": {}},
+    },
+    {
+        "name": "fahali_symbol_record",
+        "description": "Judged track record for one symbol: last 9 calls with hit/miss outcomes and replay URLs.",
+        "parameters": {"type": "object", "properties": {"symbol": {"type": "string"}}, "required": ["symbol"]},
+    },
+    {
+        "name": "fahali_track_record",
+        "description": "Aggregate scorecard: directional/magnitude/forecast axes with sample sizes and disclosed gap windows. Read lift vs base rate, never raw percentages.",
+        "parameters": {"type": "object", "properties": {}},
+    },
+    {
+        "name": "fahali_recent_alerts",
+        "description": "Latest engine detections (volume anomalies, dark-pool proxy, regime flips, whale flows...) across ~600 instruments.",
+        "parameters": {"type": "object", "properties": {}},
+    },
+]
+
+
+def execute_tool(client: FahaliClient, name: str, args: Optional[dict[str, Any]] = None) -> Any:
+    """Execute a TOOL_SPECS call by name."""
+    a = args or {}
+    if name == "fahali_verdict":
+        return client.verdict(list(a.get("symbols") or []))
+    if name == "fahali_forecast_72h":
+        return client.forecast_72h(str(a.get("symbol", "")))
+    if name == "fahali_tape":
+        return client.tape()
+    if name == "fahali_symbol_record":
+        return client.symbol_record(str(a.get("symbol", "")))
+    if name == "fahali_track_record":
+        return client.track_record()
+    if name == "fahali_recent_alerts":
+        return client.recent_alerts()
+    raise FahaliError(f"Unknown Fahali tool: {name}")

fahali-0.1.0/fahali/crewai.py

@@ -0,0 +1,36 @@
+"""CrewAI adapter: `pip install fahali crewai-tools`."""
+from __future__ import annotations
+from . import FahaliClient, execute_tool
+
+
+def get_crewai_tools(client: FahaliClient) -> list:
+    """BaseTool list for CrewAI agents."""
+    import json
+    from crewai.tools import tool  # lazy
+
+    @tool("fahali_verdict")
+    def fahali_verdict(symbols: str) -> str:
+        """Committee market verdict for comma-separated symbols (e.g. 'BTCUSDT,ETHUSDT'). 18 engines vote; includes agreement, dissent on the record, a signed receipt and a public replay URL. Observation, not advice."""
+        return json.dumps(execute_tool(client, "fahali_verdict", {"symbols": symbols.split(",")}))
+
+    @tool("fahali_forecast_72h")
+    def fahali_forecast_72h(symbol: str) -> str:
+        """72-hour crash/neutral/pump probability forecast for one symbol, Brier-calibrated."""
+        return json.dumps(execute_tool(client, "fahali_forecast_72h", {"symbol": symbol}))
+
+    @tool("fahali_tape")
+    def fahali_tape() -> str:
+        """The live tape: latest judged calls, hits AND misses, with replay URLs."""
+        return json.dumps(execute_tool(client, "fahali_tape"))
+
+    @tool("fahali_symbol_record")
+    def fahali_symbol_record(symbol: str) -> str:
+        """Judged track record for one symbol - last 9 calls, misses included."""
+        return json.dumps(execute_tool(client, "fahali_symbol_record", {"symbol": symbol}))
+
+    @tool("fahali_track_record")
+    def fahali_track_record() -> str:
+        """Aggregate scorecard with sample sizes and disclosed gaps - read lift vs base rate."""
+        return json.dumps(execute_tool(client, "fahali_track_record"))
+
+    return [fahali_verdict, fahali_forecast_72h, fahali_tape, fahali_symbol_record, fahali_track_record]

fahali-0.1.0/fahali/langchain.py

@@ -0,0 +1,22 @@
+"""LangChain adapter: `pip install fahali langchain-core`."""
+from __future__ import annotations
+from typing import Any
+from . import FahaliClient, TOOL_SPECS, execute_tool
+
+
+def get_langchain_tools(client: FahaliClient) -> list:
+    """StructuredTool list for LangChain / LangGraph agents."""
+    from langchain_core.tools import StructuredTool  # lazy
+
+    tools = []
+    for spec in TOOL_SPECS:
+        def _make(name: str):
+            def _run(**kwargs: Any) -> str:
+                import json
+                return json.dumps(execute_tool(client, name, kwargs))
+            return _run
+        tools.append(StructuredTool.from_function(
+            func=_make(spec["name"]), name=spec["name"],
+            description=spec["description"], args_schema=None,
+        ))
+    return tools

fahali-0.1.0/fahali/llamaindex.py

@@ -0,0 +1,19 @@
+"""LlamaIndex adapter: `pip install fahali llama-index-core`."""
+from __future__ import annotations
+from . import FahaliClient, TOOL_SPECS, execute_tool
+
+
+def get_llamaindex_tools(client: FahaliClient) -> list:
+    """FunctionTool list for LlamaIndex agents."""
+    import json
+    from llama_index.core.tools import FunctionTool  # lazy
+
+    tools = []
+    for spec in TOOL_SPECS:
+        def _make(name: str):
+            def _run(**kwargs) -> str:
+                return json.dumps(execute_tool(client, name, kwargs))
+            _run.__name__ = name
+            return _run
+        tools.append(FunctionTool.from_defaults(fn=_make(spec["name"]), name=spec["name"], description=spec["description"]))
+    return tools

fahali-0.1.0/pyproject.toml

@@ -0,0 +1,24 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "fahali"
+version = "0.1.0"
+description = "Market intelligence AI agents can verify - signed receipts, judged track record (misses included), Brier-calibrated forecasts. Adapters for LangChain, CrewAI, LlamaIndex, AutoGen, smolagents. MCP: mcp.fahaliai.com"
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.9"
+authors = [{ name = "Future Legends AI", email = "robert@futurelegendsai.com" }]
+keywords = ["ai-agents", "mcp", "market-intelligence", "langchain", "crewai", "llamaindex", "function-calling", "crypto", "risk"]
+classifiers = [
+  "Intended Audience :: Developers",
+  "License :: OSI Approved :: MIT License",
+  "Programming Language :: Python :: 3",
+  "Topic :: Office/Business :: Financial :: Investment",
+]
+
+[project.urls]
+Homepage = "https://fahaliai.com/developer"
+Documentation = "https://fahaliai.com/developer"
+Repository = "https://github.com/BobMain-2025/fahali-integrations"