simplefunctions-ai 0.1.0__tar.gz

simplefunctions_ai-0.1.0/.gitignore

@@ -0,0 +1,7 @@
+__pycache__/
+*.pyc
+dist/
+*.egg-info/
+.eggs/
+build/
+.env

simplefunctions_ai-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 SimpleFunctions
+
+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.

simplefunctions_ai-0.1.0/PKG-INFO

@@ -0,0 +1,186 @@
+Metadata-Version: 2.4
+Name: simplefunctions-ai
+Version: 0.1.0
+Summary: Calibrated world model for AI agents. Real-time probabilities from 9,706 prediction markets.
+Project-URL: Homepage, https://simplefunctions.dev
+Project-URL: Documentation, https://simplefunctions.dev/docs/guide
+Project-URL: Repository, https://github.com/spfunctions/simplefunctions-python
+Project-URL: World State API, https://simplefunctions.dev/api/agent/world
+Project-URL: MCP Server, https://simplefunctions.dev/api/mcp/mcp
+Author-email: SimpleFunctions <hello@simplefunctions.dev>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: agent-context,ai-agents,anthropic,geopolitics,kalshi,langchain,mcp,openai,polymarket,prediction-markets,probabilities,real-time-data,world-model,world-state
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+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: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.9
+Requires-Dist: requests>=2.28.0
+Description-Content-Type: text/markdown
+
+# SimpleFunctions
+
+Calibrated world model for AI agents. Real-time probabilities from 9,706 prediction markets.
+
+Your agent doesn't know what's happening in the world. Web search returns narratives ("tensions remain elevated"). SimpleFunctions returns calibrated numbers backed by real money: `Iran invasion: 53% (+5c, $225K volume)`.
+
+## Install
+
+```bash
+pip install simplefunctions
+```
+
+## Quick Start
+
+```python
+from simplefunctions import world, delta, scan
+
+# What's happening in the world right now? (~800 tokens, markdown)
+print(world())
+
+# What changed in the last hour? (~30-50 tokens)
+print(delta(since="1h"))
+
+# Search prediction markets
+results = scan("fed rate cut")
+for m in results["markets"][:5]:
+    print(f"{m['title']}: {m['price']}c")
+```
+
+No API key needed. Free. Data from Kalshi (CFTC-regulated) and Polymarket, updated every 15 minutes.
+
+## Give Your Agent World Awareness
+
+### System prompt injection (simplest)
+
+```python
+from simplefunctions import world
+import anthropic
+
+client = anthropic.Anthropic()
+state = world()
+
+response = client.messages.create(
+    model="claude-sonnet-4-20250514",
+    max_tokens=1024,
+    system=f"You are a research analyst.\n\n{state}",
+    messages=[{"role": "user", "content": "What's the recession probability?"}],
+)
+# Agent cites "33%" instead of hallucinating
+```
+
+### Tool definitions (one line per framework)
+
+```python
+from simplefunctions.integrations import openai_tools, anthropic_tools, mistral_tools
+
+# OpenAI Agents SDK / Responses API
+tools = openai_tools()
+
+# Anthropic Claude
+tools = anthropic_tools()
+
+# Mistral
+tools = mistral_tools()
+```
+
+### Tool execution (framework-agnostic)
+
+```python
+from simplefunctions.integrations import execute_tool
+
+# Works with any framework's tool call output
+result = execute_tool("get_world_state", {"focus": "energy,geopolitics"})
+result = execute_tool("search_prediction_markets", {"query": "iran oil"})
+result = execute_tool("get_world_delta", {"since": "1h"})
+```
+
+## API Reference
+
+### World State
+
+| Function | Description | Tokens |
+|----------|-------------|--------|
+| `world()` | Full world state — 6 topics, anchor contracts, edges, divergences | ~800 |
+| `world(focus="energy,geo")` | Same budget, concentrated on fewer topics | ~800 |
+| `delta(since="1h")` | Only what changed since timestamp | ~30-50 |
+
+### Market Data
+
+| Function | Description |
+|----------|-------------|
+| `scan("iran oil")` | Cross-venue market search with relevance ranking |
+| `market("KXRECESSION-26DEC31")` | Single market profile with optional orderbook |
+| `contagion(window="6h")` | Cross-market anomaly detection |
+| `index()` | SF Prediction Market Index (uncertainty, geo risk, momentum) |
+| `query("fed rate cut?")` | LLM-synthesized answer with live data |
+| `edges()` | Top mispriced markets across all theses |
+| `briefing(topic="iran")` | Daily topic briefing with X sentiment |
+| `diff(topic="energy")` | Market derivatives over time |
+| `changes(type="price_move")` | Recent price moves, new contracts, settlements |
+| `context()` | Global market intelligence snapshot |
+
+### Focused World State
+
+```python
+# Default: 4 contracts per topic across 6 topics
+world()
+
+# Focused: 10 contracts per topic across 2 topics
+world(focus="geopolitics,energy")
+
+# All topics: geopolitics, economy, energy, elections, crypto, tech
+```
+
+### Incremental Updates
+
+```python
+# Full state at session start
+state = world()
+
+# Periodic refresh — only changes (~30-50 tokens)
+changes = delta(since="1h")
+changes = delta(since="6h")
+changes = delta(since="2026-04-02T08:00:00Z")
+```
+
+## MCP Server
+
+For Claude Code, Cursor, or any MCP-compatible agent:
+
+```bash
+claude mcp add simplefunctions --url https://simplefunctions.dev/api/mcp/mcp
+```
+
+40 tools, no API key needed for public endpoints.
+
+## Why Prediction Markets?
+
+A prediction market price of 53c on "Iran invasion" encodes the aggregate judgment of everyone with money at risk on that question. Get it wrong, lose money. This punishment mechanism produces calibrated probabilities more reliable than any analyst report, news summary, or LLM reasoning.
+
+| | Web Search | News API | SimpleFunctions |
+|---|---|---|---|
+| **Output** | Narrative text | Headlines | Calibrated probabilities |
+| **Token cost** | 2,000-5,000 | 500-1,000 | ~800 for everything |
+| **Latency** | 2-5 seconds | 500ms | ~200ms (cached) |
+| **Calibration** | None | None | Real money at risk |
+
+## Links
+
+- [World State API](https://simplefunctions.dev/api/agent/world) — try it now
+- [Interactive demo](https://simplefunctions.dev/world)
+- [Documentation](https://simplefunctions.dev/docs/guide)
+- [All endpoints](https://simplefunctions.dev/api/tools)
+- [MCP Server](https://simplefunctions.dev/api/mcp/mcp)
+- [npm CLI](https://www.npmjs.com/package/@spfunctions/cli) — `npm install -g @spfunctions/cli`
+
+## License
+
+MIT

simplefunctions_ai-0.1.0/README.md

@@ -0,0 +1,159 @@
+# SimpleFunctions
+
+Calibrated world model for AI agents. Real-time probabilities from 9,706 prediction markets.
+
+Your agent doesn't know what's happening in the world. Web search returns narratives ("tensions remain elevated"). SimpleFunctions returns calibrated numbers backed by real money: `Iran invasion: 53% (+5c, $225K volume)`.
+
+## Install
+
+```bash
+pip install simplefunctions
+```
+
+## Quick Start
+
+```python
+from simplefunctions import world, delta, scan
+
+# What's happening in the world right now? (~800 tokens, markdown)
+print(world())
+
+# What changed in the last hour? (~30-50 tokens)
+print(delta(since="1h"))
+
+# Search prediction markets
+results = scan("fed rate cut")
+for m in results["markets"][:5]:
+    print(f"{m['title']}: {m['price']}c")
+```
+
+No API key needed. Free. Data from Kalshi (CFTC-regulated) and Polymarket, updated every 15 minutes.
+
+## Give Your Agent World Awareness
+
+### System prompt injection (simplest)
+
+```python
+from simplefunctions import world
+import anthropic
+
+client = anthropic.Anthropic()
+state = world()
+
+response = client.messages.create(
+    model="claude-sonnet-4-20250514",
+    max_tokens=1024,
+    system=f"You are a research analyst.\n\n{state}",
+    messages=[{"role": "user", "content": "What's the recession probability?"}],
+)
+# Agent cites "33%" instead of hallucinating
+```
+
+### Tool definitions (one line per framework)
+
+```python
+from simplefunctions.integrations import openai_tools, anthropic_tools, mistral_tools
+
+# OpenAI Agents SDK / Responses API
+tools = openai_tools()
+
+# Anthropic Claude
+tools = anthropic_tools()
+
+# Mistral
+tools = mistral_tools()
+```
+
+### Tool execution (framework-agnostic)
+
+```python
+from simplefunctions.integrations import execute_tool
+
+# Works with any framework's tool call output
+result = execute_tool("get_world_state", {"focus": "energy,geopolitics"})
+result = execute_tool("search_prediction_markets", {"query": "iran oil"})
+result = execute_tool("get_world_delta", {"since": "1h"})
+```
+
+## API Reference
+
+### World State
+
+| Function | Description | Tokens |
+|----------|-------------|--------|
+| `world()` | Full world state — 6 topics, anchor contracts, edges, divergences | ~800 |
+| `world(focus="energy,geo")` | Same budget, concentrated on fewer topics | ~800 |
+| `delta(since="1h")` | Only what changed since timestamp | ~30-50 |
+
+### Market Data
+
+| Function | Description |
+|----------|-------------|
+| `scan("iran oil")` | Cross-venue market search with relevance ranking |
+| `market("KXRECESSION-26DEC31")` | Single market profile with optional orderbook |
+| `contagion(window="6h")` | Cross-market anomaly detection |
+| `index()` | SF Prediction Market Index (uncertainty, geo risk, momentum) |
+| `query("fed rate cut?")` | LLM-synthesized answer with live data |
+| `edges()` | Top mispriced markets across all theses |
+| `briefing(topic="iran")` | Daily topic briefing with X sentiment |
+| `diff(topic="energy")` | Market derivatives over time |
+| `changes(type="price_move")` | Recent price moves, new contracts, settlements |
+| `context()` | Global market intelligence snapshot |
+
+### Focused World State
+
+```python
+# Default: 4 contracts per topic across 6 topics
+world()
+
+# Focused: 10 contracts per topic across 2 topics
+world(focus="geopolitics,energy")
+
+# All topics: geopolitics, economy, energy, elections, crypto, tech
+```
+
+### Incremental Updates
+
+```python
+# Full state at session start
+state = world()
+
+# Periodic refresh — only changes (~30-50 tokens)
+changes = delta(since="1h")
+changes = delta(since="6h")
+changes = delta(since="2026-04-02T08:00:00Z")
+```
+
+## MCP Server
+
+For Claude Code, Cursor, or any MCP-compatible agent:
+
+```bash
+claude mcp add simplefunctions --url https://simplefunctions.dev/api/mcp/mcp
+```
+
+40 tools, no API key needed for public endpoints.
+
+## Why Prediction Markets?
+
+A prediction market price of 53c on "Iran invasion" encodes the aggregate judgment of everyone with money at risk on that question. Get it wrong, lose money. This punishment mechanism produces calibrated probabilities more reliable than any analyst report, news summary, or LLM reasoning.
+
+| | Web Search | News API | SimpleFunctions |
+|---|---|---|---|
+| **Output** | Narrative text | Headlines | Calibrated probabilities |
+| **Token cost** | 2,000-5,000 | 500-1,000 | ~800 for everything |
+| **Latency** | 2-5 seconds | 500ms | ~200ms (cached) |
+| **Calibration** | None | None | Real money at risk |
+
+## Links
+
+- [World State API](https://simplefunctions.dev/api/agent/world) — try it now
+- [Interactive demo](https://simplefunctions.dev/world)
+- [Documentation](https://simplefunctions.dev/docs/guide)
+- [All endpoints](https://simplefunctions.dev/api/tools)
+- [MCP Server](https://simplefunctions.dev/api/mcp/mcp)
+- [npm CLI](https://www.npmjs.com/package/@spfunctions/cli) — `npm install -g @spfunctions/cli`
+
+## License
+
+MIT

simplefunctions_ai-0.1.0/pyproject.toml

@@ -0,0 +1,44 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "simplefunctions-ai"
+version = "0.1.0"
+description = "Calibrated world model for AI agents. Real-time probabilities from 9,706 prediction markets."
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.9"
+authors = [
+    { name = "SimpleFunctions", email = "hello@simplefunctions.dev" },
+]
+keywords = [
+    "prediction-markets", "world-model", "ai-agents", "real-time-data",
+    "kalshi", "polymarket", "langchain", "openai", "anthropic", "mcp",
+    "agent-context", "world-state", "probabilities", "geopolitics",
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+]
+dependencies = [
+    "requests>=2.28.0",
+]
+
+[project.urls]
+Homepage = "https://simplefunctions.dev"
+Documentation = "https://simplefunctions.dev/docs/guide"
+Repository = "https://github.com/spfunctions/simplefunctions-python"
+"World State API" = "https://simplefunctions.dev/api/agent/world"
+"MCP Server" = "https://simplefunctions.dev/api/mcp/mcp"
+
+[tool.hatch.build.targets.wheel]
+packages = ["simplefunctions"]

simplefunctions_ai-0.1.0/simplefunctions/__init__.py

@@ -0,0 +1,57 @@
+"""
+SimpleFunctions — Calibrated world model for AI agents.
+
+Real-time probabilities from 9,706 prediction markets (Kalshi + Polymarket).
+No API key needed for public endpoints. Data updated every 15 minutes.
+
+Quick start:
+
+    from simplefunctions import world, delta, scan
+
+    # Get the current state of the world (~800 tokens, markdown)
+    print(world())
+
+    # What changed in the last hour? (~30-50 tokens)
+    print(delta(since="1h"))
+
+    # Search prediction markets
+    print(scan("iran oil"))
+
+For LLM tool definitions:
+
+    from simplefunctions.integrations import openai_tools, anthropic_tools
+
+Source: SimpleFunctions World Model — 9,706 markets, calibrated by real money.
+https://simplefunctions.dev
+"""
+
+from simplefunctions.client import (
+    world,
+    delta,
+    scan,
+    market,
+    contagion,
+    index,
+    query,
+    edges,
+    context,
+    briefing,
+    diff,
+    changes,
+)
+
+__version__ = "0.1.0"
+__all__ = [
+    "world",
+    "delta",
+    "scan",
+    "market",
+    "contagion",
+    "index",
+    "query",
+    "edges",
+    "context",
+    "briefing",
+    "diff",
+    "changes",
+]

simplefunctions_ai-0.1.0/simplefunctions/client.py

@@ -0,0 +1,278 @@
+"""
+HTTP client for SimpleFunctions API.
+
+All public endpoints require no authentication.
+Authenticated endpoints (thesis, trading) require an API key from
+https://simplefunctions.dev/dashboard/keys
+"""
+
+from __future__ import annotations
+
+from typing import Any, Optional
+import requests
+
+BASE_URL = "https://simplefunctions.dev"
+
+_session: Optional[requests.Session] = None
+
+
+def _get_session() -> requests.Session:
+    global _session
+    if _session is None:
+        _session = requests.Session()
+        _session.headers["User-Agent"] = "simplefunctions-python/0.1.0"
+    return _session
+
+
+def _get(path: str, params: Optional[dict[str, Any]] = None) -> requests.Response:
+    resp = _get_session().get(f"{BASE_URL}{path}", params=params, timeout=30)
+    resp.raise_for_status()
+    return resp
+
+
+# ── World State ────────────────────────────────────────────────────────────────
+
+
+def world(
+    focus: str = "",
+    format: str = "markdown",
+) -> str:
+    """Real-time world model for AI agents.
+
+    Returns ~800 tokens covering geopolitics, economy, energy, elections,
+    crypto, tech. Anchor contracts (recession, Fed, Iran invasion) always
+    present. Calibrated by prediction markets — real money at risk.
+
+    Args:
+        focus: Comma-separated topics for deeper coverage. Same token budget,
+               concentrated on fewer topics. Options: geopolitics, economy,
+               energy, elections, crypto, tech.
+        format: "markdown" (default, optimized for LLM context) or "json".
+
+    Returns:
+        Markdown string (default) or JSON string.
+
+    Example:
+        >>> from simplefunctions import world
+        >>> print(world())                           # full panorama
+        >>> print(world(focus="energy,geopolitics"))  # deeper on 2 topics
+        >>> data = world(format="json")               # structured JSON
+    """
+    params: dict[str, str] = {}
+    if focus:
+        params["focus"] = focus
+    if format != "markdown":
+        params["format"] = format
+    return _get("/api/agent/world", params or None).text
+
+
+def delta(since: str = "1h", format: str = "markdown") -> str:
+    """Incremental world state update — only what changed.
+
+    Returns ~30-50 tokens instead of 800. For agents in long-running
+    sessions that need periodic world awareness refresh.
+
+    Args:
+        since: Relative ("30m", "1h", "6h", "24h") or ISO timestamp.
+        format: "markdown" or "json".
+
+    Example:
+        >>> from simplefunctions import delta
+        >>> print(delta(since="1h"))   # what changed in the last hour
+        >>> print(delta(since="6h"))   # last 6 hours
+    """
+    params: dict[str, str] = {"since": since}
+    if format != "markdown":
+        params["format"] = format
+    return _get("/api/agent/world/delta", params).text
+
+
+# ── Market Data ────────────────────────────────────────────────────────────────
+
+
+def scan(q: str, venue: str = "", limit: int = 20) -> dict[str, Any]:
+    """Search prediction markets across Kalshi + Polymarket.
+
+    Returns prices, spreads, volumes with relevance ranking.
+
+    Args:
+        q: Natural language query, e.g. "iran oil", "fed rate cut", "bitcoin".
+        venue: Filter by venue: "kalshi" or "polymarket". Empty for both.
+        limit: Max results (default 20, max 50).
+
+    Example:
+        >>> from simplefunctions import scan
+        >>> results = scan("recession")
+        >>> for m in results["markets"][:5]:
+        ...     print(f"{m['title']}: {m['price']}c")
+    """
+    params: dict[str, Any] = {"q": q, "limit": limit}
+    if venue:
+        params["venue"] = venue
+    return _get("/api/public/scan", params).json()
+
+
+def market(ticker: str, depth: bool = False) -> dict[str, Any]:
+    """Complete market profile for a single contract.
+
+    Price, bid/ask, spread, volume, status, description.
+    Optional 5-level orderbook depth.
+
+    Args:
+        ticker: Kalshi ticker (e.g. "KXIRANINVASION") or Polymarket conditionId.
+        depth: Include 5-level orderbook (default False).
+
+    Example:
+        >>> from simplefunctions import market
+        >>> m = market("KXRECESSION-26DEC31", depth=True)
+        >>> print(f"Price: {m['price']}c, Spread: {m['spread']}c")
+    """
+    params: dict[str, Any] = {}
+    if depth:
+        params["depth"] = "true"
+    return _get(f"/api/public/market/{ticker}", params or None).json()
+
+
+def contagion(window: str = "6h") -> dict[str, Any]:
+    """Cross-market anomaly detection.
+
+    When market A moves, which causally connected markets SHOULD move
+    but haven't? The gap is a potential edge.
+
+    Args:
+        window: Lookback window: "1h", "6h", "24h", "3d".
+
+    Example:
+        >>> from simplefunctions import contagion
+        >>> data = contagion(window="24h")
+        >>> for signal in data["signals"][:3]:
+        ...     print(f"Trigger: {signal['trigger']['ticker']} → {len(signal['lagging'])} lagging")
+    """
+    return _get("/api/public/contagion", {"window": window}).json()
+
+
+def index(history: bool = False) -> dict[str, Any]:
+    """SF Prediction Market Index.
+
+    Uncertainty (0-100), Geopolitical Risk (0-100), Momentum (-1 to +1),
+    Activity (0-100). Computed from 548 orderbook-tracked tickers.
+
+    Args:
+        history: Include 24h hourly trajectory (default False).
+
+    Example:
+        >>> from simplefunctions import index
+        >>> idx = index()
+        >>> print(f"Geo Risk: {idx['geopolitical']}/100")
+    """
+    params: dict[str, Any] = {}
+    if history:
+        params["history"] = "true"
+    return _get("/api/public/index", params or None).json()
+
+
+def query(q: str, mode: str = "full", depth: bool = False) -> dict[str, Any]:
+    """Ask any question about future events or probabilities.
+
+    Returns live contract prices from Kalshi + Polymarket, X/Twitter
+    sentiment, traditional market prices, and an LLM-synthesized answer.
+
+    Args:
+        q: Natural language query.
+        mode: "full" (LLM synthesis, default) or "raw" (data only, fastest).
+        depth: Include orderbook depth for top markets.
+
+    Example:
+        >>> from simplefunctions import query
+        >>> result = query("fed rate cut probability 2026")
+        >>> print(result["answer"])
+    """
+    params: dict[str, Any] = {"q": q, "mode": mode}
+    if depth:
+        params["depth"] = "true"
+    return _get("/api/public/query", params).json()
+
+
+def edges() -> dict[str, Any]:
+    """Aggregated edges across all public theses.
+
+    Sorted by |adjustedEdge|. Each edge = model price vs market price.
+
+    Example:
+        >>> from simplefunctions import edges
+        >>> for e in edges()["edges"][:5]:
+        ...     print(f"{e['title']}: {e['edge']}c edge")
+    """
+    return _get("/api/edges").json()
+
+
+def context(compact: bool = False, q: str = "") -> dict[str, Any]:
+    """Global market intelligence snapshot.
+
+    Top edges, price movers, highlights, traditional markets.
+
+    Args:
+        compact: Edges + highlights + traditional only.
+        q: Filter by keyword.
+    """
+    params: dict[str, Any] = {}
+    if compact:
+        params["compact"] = "true"
+    if q:
+        params["q"] = q
+    return _get("/api/public/context", params or None).json()
+
+
+def briefing(topic: str, window: str = "24h") -> dict[str, Any]:
+    """Daily topic briefing: what changed, key movers, X sentiment, outlook.
+
+    Args:
+        topic: One of: iran, oil, fed, economy, elections, crypto, china,
+               ukraine, tech, climate.
+        window: Time window (default "24h").
+    """
+    return _get("/api/public/briefing", {"topic": topic, "window": window}).json()
+
+
+def diff(
+    tickers: str = "",
+    topic: str = "",
+    window: str = "24h",
+) -> dict[str, Any]:
+    """Market derivatives: price/volume/spread deltas over time.
+
+    Detects divergence signals (volume spike + flat price, liquidity exit).
+
+    Args:
+        tickers: Comma-separated tickers.
+        topic: Or use topic to auto-resolve tickers.
+        window: Time window (default "24h").
+    """
+    params: dict[str, Any] = {"window": window}
+    if tickers:
+        params["tickers"] = tickers
+    if topic:
+        params["topic"] = topic
+    return _get("/api/public/diff", params).json()
+
+
+def changes(
+    since: str = "",
+    q: str = "",
+    type: str = "",
+) -> dict[str, Any]:
+    """Server-side detected price moves, new contracts, settlements.
+
+    Args:
+        since: ISO timestamp (default: 1h ago).
+        q: Filter by keyword.
+        type: "price_move", "new_contract", or "removed_contract".
+    """
+    params: dict[str, Any] = {}
+    if since:
+        params["since"] = since
+    if q:
+        params["q"] = q
+    if type:
+        params["type"] = type
+    return _get("/api/changes", params or None).json()

simplefunctions_ai-0.1.0/simplefunctions/integrations.py

@@ -0,0 +1,195 @@
+"""
+Ready-to-use LLM tool definitions for major frameworks.
+
+    from simplefunctions.integrations import openai_tools, anthropic_tools, langchain_tools
+
+Each returns tool definitions in the format expected by that framework.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+
+# ── Shared tool specs ──────────────────────────────────────────────────────────
+
+_TOOLS = [
+    {
+        "name": "get_world_state",
+        "description": "Get the current state of the world from prediction markets. Returns ~800 tokens of calibrated probabilities covering geopolitics, economy, energy, elections, crypto, tech. Anchor contracts (recession, Fed, Iran invasion) always present. Use focus parameter to concentrate token budget on fewer topics for deeper coverage. Source: SimpleFunctions World Model.",
+        "params": {
+            "focus": {
+                "type": "string",
+                "description": "Comma-separated topics for deeper coverage: geopolitics, economy, energy, elections, crypto, tech. Empty for all topics.",
+                "required": False,
+            },
+        },
+        "fn": "world",
+    },
+    {
+        "name": "get_world_delta",
+        "description": "Get only what changed in the world since a given time. Returns ~30-50 tokens vs 800 for full state. Use for periodic refresh during long-running tasks.",
+        "params": {
+            "since": {
+                "type": "string",
+                "description": "Relative time (30m, 1h, 6h, 24h) or ISO timestamp.",
+                "required": True,
+            },
+        },
+        "fn": "delta",
+    },
+    {
+        "name": "search_prediction_markets",
+        "description": "Search prediction markets for specific contracts across Kalshi and Polymarket. Returns prices, volumes, and spreads with relevance ranking.",
+        "params": {
+            "query": {
+                "type": "string",
+                "description": "Natural language search query, e.g. 'iran oil', 'fed rate cut', 'bitcoin price'.",
+                "required": True,
+            },
+        },
+        "fn": "scan",
+    },
+    {
+        "name": "get_market_detail",
+        "description": "Get detailed data for a specific prediction market contract. Includes price, spread, volume, orderbook depth, and thesis edges.",
+        "params": {
+            "ticker": {
+                "type": "string",
+                "description": "Kalshi ticker (e.g. KXRECESSION-26DEC31) or Polymarket condition ID.",
+                "required": True,
+            },
+        },
+        "fn": "market",
+    },
+    {
+        "name": "get_cross_market_contagion",
+        "description": "Detect cross-market anomalies: what should have moved but hasn't. When causally connected markets diverge, the gap is a potential edge.",
+        "params": {
+            "window": {
+                "type": "string",
+                "description": "Lookback window: 1h, 6h, 24h, 3d.",
+                "required": False,
+            },
+        },
+        "fn": "contagion",
+    },
+]
+
+
+# ── OpenAI function calling ───────────────────────────────────────────────────
+
+
+def openai_tools() -> list[dict[str, Any]]:
+    """Return tool definitions for OpenAI function calling (Responses API / Agents SDK).
+
+    Example:
+        from simplefunctions.integrations import openai_tools
+        tools = openai_tools()
+        response = client.responses.create(model="gpt-4o", tools=tools, ...)
+    """
+    result = []
+    for t in _TOOLS:
+        properties = {}
+        required = []
+        for pname, pspec in t["params"].items():
+            properties[pname] = {
+                "type": pspec["type"],
+                "description": pspec["description"],
+            }
+            if pspec.get("required"):
+                required.append(pname)
+
+        result.append({
+            "type": "function",
+            "function": {
+                "name": t["name"],
+                "description": t["description"],
+                "parameters": {
+                    "type": "object",
+                    "properties": properties,
+                    **({"required": required} if required else {}),
+                },
+            },
+        })
+    return result
+
+
+# ── Anthropic tool use ─────────────────────────────────────────────────────────
+
+
+def anthropic_tools() -> list[dict[str, Any]]:
+    """Return tool definitions for Anthropic Claude tool use.
+
+    Example:
+        from simplefunctions.integrations import anthropic_tools
+        tools = anthropic_tools()
+        response = client.messages.create(model="claude-sonnet-4-20250514", tools=tools, ...)
+    """
+    result = []
+    for t in _TOOLS:
+        properties = {}
+        required = []
+        for pname, pspec in t["params"].items():
+            properties[pname] = {
+                "type": pspec["type"],
+                "description": pspec["description"],
+            }
+            if pspec.get("required"):
+                required.append(pname)
+
+        result.append({
+            "name": t["name"],
+            "description": t["description"],
+            "input_schema": {
+                "type": "object",
+                "properties": properties,
+                **({"required": required} if required else {}),
+            },
+        })
+    return result
+
+
+# ── Mistral function calling ──────────────────────────────────────────────────
+
+
+def mistral_tools() -> list[dict[str, Any]]:
+    """Return tool definitions for Mistral function calling.
+
+    Example:
+        from simplefunctions.integrations import mistral_tools
+        tools = mistral_tools()
+        response = client.chat.complete(model="mistral-large-latest", tools=tools, ...)
+    """
+    # Same format as OpenAI
+    return openai_tools()
+
+
+# ── Tool executor ──────────────────────────────────────────────────────────────
+
+
+def execute_tool(name: str, arguments: dict[str, Any]) -> str:
+    """Execute a SimpleFunctions tool call and return the result as a string.
+
+    Works with any framework's tool calling output.
+
+    Example:
+        from simplefunctions.integrations import execute_tool
+        result = execute_tool("get_world_state", {"focus": "energy,geopolitics"})
+        result = execute_tool("search_prediction_markets", {"query": "iran"})
+    """
+    import json
+    from simplefunctions import client
+
+    if name == "get_world_state":
+        return client.world(focus=arguments.get("focus", ""))
+    elif name == "get_world_delta":
+        return client.delta(since=arguments.get("since", "1h"))
+    elif name == "search_prediction_markets":
+        return json.dumps(client.scan(q=arguments["query"]), indent=2)
+    elif name == "get_market_detail":
+        return json.dumps(client.market(ticker=arguments["ticker"]), indent=2)
+    elif name == "get_cross_market_contagion":
+        return json.dumps(client.contagion(window=arguments.get("window", "6h")), indent=2)
+    else:
+        return f"Unknown tool: {name}"