x402-omni-oracle 0.1.0

package/examples/route.ts

@@ -0,0 +1,28 @@
+import { streamText } from 'ai';
+import { openai } from '@ai-sdk/openai';
+import {
+    getKLAXThermalRisk,
+    getCoinGeckoPrice,
+    getSwarmPulse
+} from '../src/index';
+
+// --- EXAMPLE NEXT.JS ROUTE HANDLER ---
+
+export async function POST(req: Request) {
+    const { messages } = await req.json() as { messages: any[] };
+
+    const result = await streamText({
+        model: openai('gpt-4-turbo'),
+        messages,
+        system: `You are an Agentic Assistant. You have access to the Omni-Oracle.
+                 Prices cost money, so ask the user before spending > 0.10 USDC.`,
+        tools: {
+            // Register whatever tools you want the agent to use
+            getKLAXThermalRisk,
+            getCoinGeckoPrice,
+            getSwarmPulse
+        }
+    });
+
+    return result.toTextStreamResponse();
+}

package/package.json

@@ -0,0 +1,31 @@
+{
+    "name": "x402-omni-oracle",
+    "version": "0.1.0",
+    "description": "Agent-First Data Provider. Native tools for Vercel AI SDK.",
+    "main": "dist/index.js",
+    "types": "dist/index.d.ts",
+    "publishConfig": {
+        "access": "public"
+    },
+    "scripts": {
+        "build": "tsc"
+    },
+    "keywords": [
+        "ai",
+        "agent",
+        "vercel",
+        "x402",
+        "oracle"
+    ],
+    "author": "Omni-Oracle",
+    "license": "MIT",
+    "dependencies": {
+        "zod": "^3.0.0"
+    },
+    "peerDependencies": {
+        "ai": "^3.0.0 || ^4.0.0"
+    },
+    "devDependencies": {
+        "typescript": "^5.0.0"
+    }
+}

package/src/index.ts

@@ -0,0 +1,1014 @@
+import { tool } from 'ai';
+import { z } from 'zod';
+
+// Base URL for Omni-Oracle
+const BASE_URL = 'https://omni-oracle.omnioracle.workers.dev';
+
+
+async function fetchOracle(path: string, params: Record<string, any> = {}) {
+    const url = new URL(`${BASE_URL}${path}`);
+    
+    // Substitute path params
+    let finalPath = path;
+    const queryParams: Record<string, any> = {};
+
+    for (const [key, value] of Object.entries(params)) {
+        if (finalPath.includes(`{${key}}`)) {
+            finalPath = finalPath.replace(`{${key}}`, String(value));
+        } else {
+            queryParams[key] = value;
+        }
+    }
+    
+    url.pathname = finalPath;
+    for (const [key, value] of Object.entries(queryParams)) {
+        if (value !== undefined && value !== null) {
+            url.searchParams.append(key, String(value));
+        }
+    }
+
+    try {
+        const res = await fetch(url.toString());
+        if (res.status === 200) {
+            return await res.json();
+        } else if (res.status === 402) {
+             return {
+                error: 'PAYMENT_REQUIRED',
+                message: 'This endpoint requires payment (USDC/ETH). Please attach X-402-Transaction-Hash header.',
+                price: res.headers.get('x-402-price'),
+                recipient: res.headers.get('x-402-recipient'),
+                endpoint: path
+            };
+        } else {
+            return { error: `HTTP ${res.status}`, message: await res.text() };
+        }
+    } catch (e: any) {
+        return { error: 'CONNECTION_ERROR', message: e.message };
+    }
+}
+
+
+export const getKLAXThermalRisk = tool({
+    description: "Aviation weather and thermal risk data for Los Angeles International Airport.",
+    parameters: z.object({}),
+    execute: async (params) => fetchOracle('/logistics/klax', params)
+});
+
+export const getKJFKThermalRisk = tool({
+    description: "Aviation weather and thermal risk data for John F. Kennedy International Airport.",
+    parameters: z.object({}),
+    execute: async (params) => fetchOracle('/logistics/kjfk', params)
+});
+
+export const getKMEMThermalRisk = tool({
+    description: "Aviation weather for Memphis International (FedEx SuperHub).",
+    parameters: z.object({}),
+    execute: async (params) => fetchOracle('/logistics/kmem', params)
+});
+
+export const getKORDThermalRisk = tool({
+    description: "Aviation weather for Chicago O'Hare International Airport.",
+    parameters: z.object({}),
+    execute: async (params) => fetchOracle('/logistics/kord', params)
+});
+
+export const getKIAHThermalRisk = tool({
+    description: "Aviation weather for George Bush Intercontinental Airport.",
+    parameters: z.object({}),
+    execute: async (params) => fetchOracle('/logistics/kiah', params)
+});
+
+export const getLHRThermalRisk = tool({
+    description: "Aviation weather for London Heathrow. Europe gateway risk.",
+    parameters: z.object({}),
+    execute: async (params) => fetchOracle('/logistics/lhr', params)
+});
+
+export const getHNDThermalRisk = tool({
+    description: "Aviation weather for Tokyo Haneda. Asia gateway risk.",
+    parameters: z.object({}),
+    execute: async (params) => fetchOracle('/logistics/hnd', params)
+});
+
+export const getDXBThermalRisk = tool({
+    description: "Aviation weather for Dubai Intl. Middle East hub risk.",
+    parameters: z.object({}),
+    execute: async (params) => fetchOracle('/logistics/dxb', params)
+});
+
+export const getHKGThermalRisk = tool({
+    description: "Aviation weather for Hong Kong. Global Air Cargo hub.",
+    parameters: z.object({}),
+    execute: async (params) => fetchOracle('/logistics/hkg', params)
+});
+
+export const getFRAThermalRisk = tool({
+    description: "Aviation weather for Frankfurt. Europe cargo hub.",
+    parameters: z.object({}),
+    execute: async (params) => fetchOracle('/logistics/fra', params)
+});
+
+export const getGreenComputeWindow = tool({
+    description: "Returns a boolean `green_window_active` flag when the US Grid carbon intensity is low (<40%). Use for scheduling AI training jobs and compute workloads.",
+    parameters: z.object({}),
+    execute: async (params) => fetchOracle('/compute/green-window', params)
+});
+
+export const getJupiterQuote = tool({
+    description: "Get optimal swap route from Jupiter Aggregator v6 on Solana.",
+    parameters: z.object({
+        inputMint: z.string().describe("Input token mint address"),
+        outputMint: z.string().describe("Output token mint address"),
+        amount: z.string().describe("Amount in smallest units"),
+        slippageBps: z.number().int().describe("Slippage tolerance in basis points").optional()
+    }),
+    execute: async (params) => fetchOracle('/finance/jupiter/quote', params)
+});
+
+export const getCoinGeckoPrice = tool({
+    description: "Real-time USD price from CoinGecko with 24h change and volatility triggers.",
+    parameters: z.object({
+        id: z.string().describe("CoinGecko token ID")
+    }),
+    execute: async (params) => fetchOracle('/finance/coingecko/price/{id}', params)
+});
+
+export const getCoinGeckoTrending = tool({
+    description: "Top 10 trending tokens on CoinGecko.",
+    parameters: z.object({}),
+    execute: async (params) => fetchOracle('/finance/coingecko/trending', params)
+});
+
+export const getGlobalMarketStats = tool({
+    description: "Total market cap, volume, and BTC/ETH dominance.",
+    parameters: z.object({}),
+    execute: async (params) => fetchOracle('/finance/coingecko/global', params)
+});
+
+export const getFREDSeries = tool({
+    description: "Economic indicator data from St. Louis Fed (CPI, GDP, Fed Funds Rate, etc.).",
+    parameters: z.object({
+        id: z.string().describe("FRED series ID")
+    }),
+    execute: async (params) => fetchOracle('/finance/fred/series/{id}', params)
+});
+
+export const getPopularEconomicIndicators = tool({
+    description: "List of commonly used FRED series with descriptions.",
+    parameters: z.object({}),
+    execute: async (params) => fetchOracle('/finance/fred/popular', params)
+});
+
+export const getDexScreenerPairs = tool({
+    description: "Real-time price, volume, and liquidity data for token pairs from DexScreener.",
+    parameters: z.object({
+        chainId: z.string().describe(""),
+        addresses: z.string().describe("Comma-separated token addresses")
+    }),
+    execute: async (params) => fetchOracle('/market/dexscreener/token-pairs/{chainId}/{addresses}', params)
+});
+
+export const getProtocolTVL = tool({
+    description: "Total Value Locked and protocol details from DeFiLlama.",
+    parameters: z.object({
+        protocol: z.string().describe("")
+    }),
+    execute: async (params) => fetchOracle('/analytics/defillama/tvl/{protocol}', params)
+});
+
+export const getTopStablecoins = tool({
+    description: "Top 5 stablecoins by market cap with peg status.",
+    parameters: z.object({}),
+    execute: async (params) => fetchOracle('/analytics/defillama/stablecoins', params)
+});
+
+export const get3Stats = tool({
+    description: "Protocol statistics from Uniswap V3 Ethereum subgraph.",
+    parameters: z.object({}),
+    execute: async (params) => fetchOracle('/analytics/thegraph/uniswap/stats', params)
+});
+
+export const getAaveV3Stats = tool({
+    description: "Protocol statistics from Aave V3 Ethereum subgraph.",
+    parameters: z.object({}),
+    execute: async (params) => fetchOracle('/analytics/thegraph/aave/stats', params)
+});
+
+export const getBitcoinFees = tool({
+    description: "Real-time recommended fees (sat/vB) from Mempool.space.",
+    parameters: z.object({}),
+    execute: async (params) => fetchOracle('/crypto/btc/fees', params)
+});
+
+export const getBitcoinBlockStatus = tool({
+    description: "Latest block height from Mempool.space.",
+    parameters: z.object({}),
+    execute: async (params) => fetchOracle('/crypto/btc/block-status', params)
+});
+
+export const getEthereumGas = tool({
+    description: "Real-time Gas (Wei) from Beaconcha.in.",
+    parameters: z.object({}),
+    execute: async (params) => fetchOracle('/crypto/eth/gas-forecast', params)
+});
+
+export const getChainlinkPrice = tool({
+    description: "On-chain price from Chainlink aggregator on Base. Available pairs: ETH/USD, BTC/USD, USDC/USD, DAI/USD, LINK/USD.",
+    parameters: z.object({
+        pair: z.string().describe("")
+    }),
+    execute: async (params) => fetchOracle('/crypto/chainlink/price/{pair}', params)
+});
+
+export const getSeismicAlerts = tool({
+    description: "List of recent significant seismic events from USGS.",
+    parameters: z.object({}),
+    execute: async (params) => fetchOracle('/risk/seismic/recent', params)
+});
+
+export const getSolarStormAlert = tool({
+    description: "Boolean `storm_active` flag for G/S/R scale events from NOAA.",
+    parameters: z.object({}),
+    execute: async (params) => fetchOracle('/risk/solar/storm-alert', params)
+});
+
+export const getMarketCrashProbability = tool({
+    description: "Composite risk score (0-100) aggregating VIX, Fear&Greed, BTC Fees. High value Alpha signal.",
+    parameters: z.object({}),
+    execute: async (params) => fetchOracle('/risk/market-crash-probability', params)
+});
+
+export const getHackerNewsTopStories = tool({
+    description: "Top 10 trending stories from HackerNews.",
+    parameters: z.object({}),
+    execute: async (params) => fetchOracle('/sentiment/hn/top-stories', params)
+});
+
+export const searchHackerNews = tool({
+    description: "Search HackerNews stories by keyword.",
+    parameters: z.object({
+        query: z.string().describe("")
+    }),
+    execute: async (params) => fetchOracle('/sentiment/hn/keyword/{query}', params)
+});
+
+export const getDailyAIPapers = tool({
+    description: "Latest AI/ML papers from ArXiv (cs.AI + cs.LG).",
+    parameters: z.object({}),
+    execute: async (params) => fetchOracle('/sentiment/arxiv/daily/ai', params)
+});
+
+export const searchArXiv = tool({
+    description: "Search ArXiv papers by keyword.",
+    parameters: z.object({
+        q: z.string().describe("")
+    }),
+    execute: async (params) => fetchOracle('/sentiment/arxiv/search', params)
+});
+
+export const getFearGreedIndex = tool({
+    description: "Current crypto Fear & Greed Index with extreme_fear/extreme_greed triggers.",
+    parameters: z.object({}),
+    execute: async (params) => fetchOracle('/sentiment/feargreed/index', params)
+});
+
+export const getFearGreedHistory = tool({
+    description: "30-day historical Fear & Greed Index with trend analysis.",
+    parameters: z.object({}),
+    execute: async (params) => fetchOracle('/sentiment/feargreed/history', params)
+});
+
+export const getMarketHeadlines = tool({
+    description: "Latest market news headlines. Requires POLYGON_API_KEY.",
+    parameters: z.object({}),
+    execute: async (params) => fetchOracle('/sentiment/news/headlines', params)
+});
+
+export const getTickerNews = tool({
+    description: "News for specific ticker with sentiment analysis. Requires POLYGON_API_KEY.",
+    parameters: z.object({
+        symbol: z.string().describe("")
+    }),
+    execute: async (params) => fetchOracle('/sentiment/news/ticker/{symbol}', params)
+});
+
+export const getIPGeolocation = tool({
+    description: "Geographic location data for an IP address.",
+    parameters: z.object({
+        address: z.string().describe("")
+    }),
+    execute: async (params) => fetchOracle('/network/ip/{address}', params)
+});
+
+export const checkSSLCertificate = tool({
+    description: "Validate SSL certificate for a domain.",
+    parameters: z.object({
+        domain: z.string().describe("")
+    }),
+    execute: async (params) => fetchOracle('/network/ssl-check', params)
+});
+
+export const convertHtmlToMarkdown = tool({
+    description: "Convert any URL to clean Markdown for easier agent consumption.",
+    parameters: z.object({
+        url: z.string().describe("")
+    }),
+    execute: async (params) => fetchOracle('/utility/html-to-markdown', params)
+});
+
+export const resolveDNS = tool({
+    description: "Resolve DNS records securely via Cloudflare DoH.",
+    parameters: z.object({
+        domain: z.string().describe(""),
+        type: z.string().describe("").optional()
+    }),
+    execute: async (params) => fetchOracle('/utility/dns-lookup', params)
+});
+
+export const validateJSON = tool({
+    description: "Validate strict JSON syntax. Returns boolean valid/invalid.",
+    parameters: z.object({}),
+    execute: async (params) => fetchOracle('/utility/json-validator', params)
+});
+
+export const convertRSStoJSON = tool({
+    description: "Convert any RSS/Atom XML feed into structured JSON.",
+    parameters: z.object({
+        url: z.string().describe("")
+    }),
+    execute: async (params) => fetchOracle('/utility/rss-to-json', params)
+});
+
+export const getSignedTimestamp = tool({
+    description: "Cryptographically signed timestamp for trusted time synchronization.",
+    parameters: z.object({}),
+    execute: async (params) => fetchOracle('/utility/timestamp', params)
+});
+
+export const convertUnits = tool({
+    description: "Convert units (c/f, kg/lbs, km/mi, eth/wei).",
+    parameters: z.object({
+        value: z.number().describe(""),
+        from: z.string().describe(""),
+        to: z.string().describe("")
+    }),
+    execute: async (params) => fetchOracle('/utility/unit-converter', params)
+});
+
+export const whoami = tool({
+    description: "Echoes back the caller identity, IP, and headers as seen by the Oracle, signed.",
+    parameters: z.object({}),
+    execute: async (params) => fetchOracle('/identity/whoami', params)
+});
+
+export const getReputationScore = tool({
+    description: "Get the credit score of an agent based on their on-chain payment history to this Oracle.",
+    parameters: z.object({
+        address: z.string().describe("")
+    }),
+    execute: async (params) => fetchOracle('/identity/score/{address}', params)
+});
+
+export const getSwarmPulse = tool({
+    description: "Real-time aggregated attention metrics from the agent swarm. 'Where are agents looking right now?'",
+    parameters: z.object({}),
+    execute: async (params) => fetchOracle('/meta/pulse', params)
+});
+
+export const getSwarmSentiment = tool({
+    description: "Crowd-sourced sentiment derived from the ratio of Risk queries vs Finance queries.",
+    parameters: z.object({}),
+    execute: async (params) => fetchOracle('/meta/sentiment', params)
+});
+
+export const getTokenMetadata = tool({
+    description: "Get logo, website, and socials for any token.",
+    parameters: z.object({
+        address: z.string().describe("")
+    }),
+    execute: async (params) => fetchOracle('/token/metadata/{address}', params)
+});
+
+export const getWhaleMovements = tool({
+    description: "Large transfers (> $1M) detected in the last hour.",
+    parameters: z.object({}),
+    execute: async (params) => fetchOracle('/whale/recent', params)
+});
+
+export const resolveENS = tool({
+    description: "Resolve ENS name to address and vice versa.",
+    parameters: z.object({
+        name: z.string().describe("")
+    }),
+    execute: async (params) => fetchOracle('/ens/resolve/{name}', params)
+});
+
+export const getBlockData = tool({
+    description: "Get block details by height or 'latest'.",
+    parameters: z.object({
+        height: z.string().describe("")
+    }),
+    execute: async (params) => fetchOracle('/chain/block/{height}', params)
+});
+
+export const checkAirdropEligibility = tool({
+    description: "Check eligibility for known active airdrops.",
+    parameters: z.object({
+        address: z.string().describe("")
+    }),
+    execute: async (params) => fetchOracle('/airdrop/check/{address}', params)
+});
+
+export const getTradePreflight = tool({
+    description: "BUNDLE: Gas + slippage + risk check before executing a swap.",
+    parameters: z.object({
+        token: z.string().describe("")
+    }),
+    execute: async (params) => fetchOracle('/preflight/trade', params)
+});
+
+export const getWalletValues = tool({
+    description: "BUNDLE: Portfolio balance across chains.",
+    parameters: z.object({
+        address: z.string().describe("")
+    }),
+    execute: async (params) => fetchOracle('/preflight/wallet', params)
+});
+
+export const getDeFiDashboard = tool({
+    description: "BUNDLE: Top yields, L2 TVL, and stablecoin health.",
+    parameters: z.object({}),
+    execute: async (params) => fetchOracle('/dashboard/defi', params)
+});
+
+export const getMarketDashboard = tool({
+    description: "BUNDLE: Fear/Greed, trending tokens, and BTC dominance.",
+    parameters: z.object({}),
+    execute: async (params) => fetchOracle('/dashboard/market', params)
+});
+
+export const getBatchPrices = tool({
+    description: "Get prices for multiple tokens in one call.",
+    parameters: z.object({
+        tokens: z.string().describe("Comma separated addresses")
+    }),
+    execute: async (params) => fetchOracle('/price/batch', params)
+});
+
+export const getStablecoinYields = tool({
+    description: "Top APY/APR for stablecoins across lending protocols.",
+    parameters: z.object({}),
+    execute: async (params) => fetchOracle('/apy/stablecoin', params)
+});
+
+export const getDAOTreasuries = tool({
+    description: "Top DAO treasury balances and holdings.",
+    parameters: z.object({}),
+    execute: async (params) => fetchOracle('/dao/treasuries', params)
+});
+
+export const getX402BazaarCatalog = tool({
+    description: "Agent discovery metadata with full service catalog and pricing.",
+    parameters: z.object({}),
+    execute: async (params) => fetchOracle('/.well-known/x402-bazaar', params)
+});
+
+export const getOpenAPISpec = tool({
+    description: "This OpenAPI 3.1 specification.",
+    parameters: z.object({}),
+    execute: async (params) => fetchOracle('/doc', params)
+});
+
+export const getMarketRegime = tool({
+    description: "SYNTHETIC: Composite market state (Risk-On/Off/Euphoria/Capitulation). Aggregates Fear&Greed, BTC mempool, stablecoin pegs.",
+    parameters: z.object({}),
+    execute: async (params) => fetchOracle('/alpha/market-regime', params)
+});
+
+export const getWhaleMomentum = tool({
+    description: "SYNTHETIC: Aggregated large transaction patterns. Are whales accumulating or distributing?",
+    parameters: z.object({}),
+    execute: async (params) => fetchOracle('/alpha/whale-momentum', params)
+});
+
+export const getSentimentDivergence = tool({
+    description: "SYNTHETIC: News sentiment vs price action divergence. Contrarian trading signals.",
+    parameters: z.object({}),
+    execute: async (params) => fetchOracle('/alpha/sentiment-divergence', params)
+});
+
+export const getRiskAdjustedYield = tool({
+    description: "SYNTHETIC: DeFi yields weighted by TVL risk and IL exposure. Best risk-adjusted returns.",
+    parameters: z.object({}),
+    execute: async (params) => fetchOracle('/alpha/risk-adjusted-yield', params)
+});
+
+export const getTrendingQueries = tool({
+    description: "UNIQUE: Real-time view of what agents are querying most. Derived from live traffic.",
+    parameters: z.object({}),
+    execute: async (params) => fetchOracle('/meta/trending-queries', params)
+});
+
+export const getSectorRotation = tool({
+    description: "UNIQUE: Track volume shifts between categories over 24h. Detect agent pivots.",
+    parameters: z.object({}),
+    execute: async (params) => fetchOracle('/meta/sector-rotation', params)
+});
+
+export const getAnomalyAlert = tool({
+    description: "UNIQUE: Unusual agent behavior pattern detection. Volume spikes and drops.",
+    parameters: z.object({}),
+    execute: async (params) => fetchOracle('/meta/anomaly-alert', params)
+});
+
+export const getSwarmConsensus = tool({
+    description: "UNIQUE: Network-wide bull/bear ratio from actual agent query patterns.",
+    parameters: z.object({}),
+    execute: async (params) => fetchOracle('/meta/consensus', params)
+});
+
+export const getSINThermalRisk = tool({
+    description: "NOAA Aviation Weather for Singapore Changi. Asia-Pacific hub.",
+    parameters: z.object({}),
+    execute: async (params) => fetchOracle('/logistics/sin', params)
+});
+
+export const getPEKThermalRisk = tool({
+    description: "NOAA Aviation Weather for Beijing Capital. China gateway.",
+    parameters: z.object({}),
+    execute: async (params) => fetchOracle('/logistics/pek', params)
+});
+
+export const getCDGThermalRisk = tool({
+    description: "NOAA Aviation Weather for Paris Charles de Gaulle.",
+    parameters: z.object({}),
+    execute: async (params) => fetchOracle('/logistics/cdg', params)
+});
+
+export const getAMSThermalRisk = tool({
+    description: "NOAA Aviation Weather for Amsterdam Schiphol.",
+    parameters: z.object({}),
+    execute: async (params) => fetchOracle('/logistics/ams', params)
+});
+
+export const getICNThermalRisk = tool({
+    description: "NOAA Aviation Weather for Seoul Incheon.",
+    parameters: z.object({}),
+    execute: async (params) => fetchOracle('/logistics/icn', params)
+});
+
+export const getSYDThermalRisk = tool({
+    description: "NOAA Aviation Weather for Sydney Kingsford Smith.",
+    parameters: z.object({}),
+    execute: async (params) => fetchOracle('/logistics/syd', params)
+});
+
+export const getGRUThermalRisk = tool({
+    description: "NOAA Aviation Weather for São Paulo Guarulhos.",
+    parameters: z.object({}),
+    execute: async (params) => fetchOracle('/logistics/gru', params)
+});
+
+export const getBOMThermalRisk = tool({
+    description: "NOAA Aviation Weather for Mumbai Chhatrapati Shivaji.",
+    parameters: z.object({}),
+    execute: async (params) => fetchOracle('/logistics/bom', params)
+});
+
+export const getJNBThermalRisk = tool({
+    description: "NOAA Aviation Weather for Johannesburg O.R. Tambo.",
+    parameters: z.object({}),
+    execute: async (params) => fetchOracle('/logistics/jnb', params)
+});
+
+export const getMEXThermalRisk = tool({
+    description: "NOAA Aviation Weather for Mexico City International.",
+    parameters: z.object({}),
+    execute: async (params) => fetchOracle('/logistics/mex', params)
+});
+
+export const getMarketHours = tool({
+    description: "Check if NYSE, NASDAQ, or crypto markets are currently open.",
+    parameters: z.object({
+        market: z.string().describe("Market: nyse, nasdaq, crypto").optional()
+    }),
+    execute: async (params) => fetchOracle('/utility/market-hours', params)
+});
+
+export const convertTimezone = tool({
+    description: "Convert time between timezones.",
+    parameters: z.object({
+        time: z.string().describe("ISO 8601 time string"),
+        from: z.string().describe("Source timezone"),
+        to: z.string().describe("Target timezone")
+    }),
+    execute: async (params) => fetchOracle('/utility/timezone-convert', params)
+});
+
+export const checkHoliday = tool({
+    description: "Check if a date is a public holiday in any country.",
+    parameters: z.object({
+        date: z.string().describe("Date YYYY-MM-DD").optional(),
+        country: z.string().describe("ISO country code")
+    }),
+    execute: async (params) => fetchOracle('/utility/holiday-check', params)
+});
+
+export const getCronNext = tool({
+    description: "Parse cron expression and get next N occurrences.",
+    parameters: z.object({
+        cron: z.string().describe("Cron expression"),
+        n: z.number().int().describe("Number of occurrences").optional()
+    }),
+    execute: async (params) => fetchOracle('/utility/cron-next', params)
+});
+
+export const getDateDiff = tool({
+    description: "Calculate difference between two dates.",
+    parameters: z.object({
+        from: z.string().describe(""),
+        to: z.string().describe("")
+    }),
+    execute: async (params) => fetchOracle('/utility/date-diff', params)
+});
+
+export const convertUnixTimestamp = tool({
+    description: "Convert Unix timestamps to ISO dates and vice versa.",
+    parameters: z.object({
+        value: z.string().describe("")
+    }),
+    execute: async (params) => fetchOracle('/utility/unix-convert', params)
+});
+
+export const getTokenUnlocks = tool({
+    description: "Upcoming token unlock events via DeFiLlama.",
+    parameters: z.object({}),
+    execute: async (params) => fetchOracle('/token/unlocks', params)
+});
+
+export const getTokenSupply = tool({
+    description: "Circulating, total, and max supply for any token.",
+    parameters: z.object({
+        id: z.string().describe("")
+    }),
+    execute: async (params) => fetchOracle('/token/supply/{id}', params)
+});
+
+export const getTokenATHATL = tool({
+    description: "ATH and ATL prices with dates.",
+    parameters: z.object({
+        id: z.string().describe("")
+    }),
+    execute: async (params) => fetchOracle('/token/ath-atl/{id}', params)
+});
+
+export const getTokenCategories = tool({
+    description: "Get categories a token belongs to.",
+    parameters: z.object({
+        id: z.string().describe("")
+    }),
+    execute: async (params) => fetchOracle('/token/categories/{id}', params)
+});
+
+export const getTokenExchanges = tool({
+    description: "Exchanges where a token trades and their volumes.",
+    parameters: z.object({
+        id: z.string().describe("")
+    }),
+    execute: async (params) => fetchOracle('/token/exchanges/{id}', params)
+});
+
+export const getProtocolsByChain = tool({
+    description: "List all DeFi protocols on a specific chain with TVL.",
+    parameters: z.object({
+        chain: z.string().describe("")
+    }),
+    execute: async (params) => fetchOracle('/defi/protocols-by-chain', params)
+});
+
+export const getTVLChange = tool({
+    description: "24h and 7d TVL changes for protocols.",
+    parameters: z.object({
+        protocol: z.string().describe("").optional()
+    }),
+    execute: async (params) => fetchOracle('/defi/tvl-change', params)
+});
+
+export const getLendingRates = tool({
+    description: "Borrow and supply APYs from Aave, Compound, etc.",
+    parameters: z.object({
+        token: z.string().describe("").optional()
+    }),
+    execute: async (params) => fetchOracle('/defi/lending-rates', params)
+});
+
+export const getStakingYields = tool({
+    description: "Native staking APYs for ETH, SOL, ATOM, etc.",
+    parameters: z.object({}),
+    execute: async (params) => fetchOracle('/defi/staking-yields', params)
+});
+
+export const getDeFiLiquidations = tool({
+    description: "Recent liquidation events and at-risk capital.",
+    parameters: z.object({}),
+    execute: async (params) => fetchOracle('/defi/liquidations', params)
+});
+
+export const getDeFiHacks = tool({
+    description: "Recent exploit and hack history from DeFiLlama.",
+    parameters: z.object({
+        days: z.number().int().describe("").optional()
+    }),
+    execute: async (params) => fetchOracle('/defi/hacks', params)
+});
+
+export const getBridgesTVL = tool({
+    description: "Cross-chain bridge TVL and volume.",
+    parameters: z.object({}),
+    execute: async (params) => fetchOracle('/defi/bridges-tvl', params)
+});
+
+export const getDEXVolume = tool({
+    description: "24h DEX trading volume by chain or globally.",
+    parameters: z.object({
+        chain: z.string().describe("").optional()
+    }),
+    execute: async (params) => fetchOracle('/defi/dex-volume', params)
+});
+
+export const getFundingRates = tool({
+    description: "Perpetual futures funding rates from Binance.",
+    parameters: z.object({
+        symbol: z.string().describe("").optional()
+    }),
+    execute: async (params) => fetchOracle('/derivatives/funding-rates', params)
+});
+
+export const getOpenInterest = tool({
+    description: "Open interest data for crypto derivatives.",
+    parameters: z.object({
+        symbol: z.string().describe("")
+    }),
+    execute: async (params) => fetchOracle('/derivatives/open-interest', params)
+});
+
+export const getLongShortRatio = tool({
+    description: "Global long vs short ratio.",
+    parameters: z.object({
+        symbol: z.string().describe("")
+    }),
+    execute: async (params) => fetchOracle('/derivatives/long-short-ratio', params)
+});
+
+export const getTopTraders = tool({
+    description: "What are the top traders doing?",
+    parameters: z.object({
+        symbol: z.string().describe("")
+    }),
+    execute: async (params) => fetchOracle('/derivatives/top-traders', params)
+});
+
+export const getDerivativesLiquidations = tool({
+    description: "Recent futures liquidation data.",
+    parameters: z.object({
+        symbol: z.string().describe("").optional()
+    }),
+    execute: async (params) => fetchOracle('/derivatives/liquidations', params)
+});
+
+export const lookupTransaction = tool({
+    description: "Look up any transaction by hash.",
+    parameters: z.object({
+        hash: z.string().describe(""),
+        chain: z.string().describe("").optional()
+    }),
+    execute: async (params) => fetchOracle('/chain/tx-lookup', params)
+});
+
+export const getAddressBalance = tool({
+    description: "Get native ETH/MATIC/etc balance for any address.",
+    parameters: z.object({
+        address: z.string().describe(""),
+        chain: z.string().describe("").optional()
+    }),
+    execute: async (params) => fetchOracle('/chain/address-balance', params)
+});
+
+export const getTokenBalances = tool({
+    description: "Check major ERC-20 token balances for an address.",
+    parameters: z.object({
+        address: z.string().describe(""),
+        chain: z.string().describe("").optional()
+    }),
+    execute: async (params) => fetchOracle('/chain/token-balances', params)
+});
+
+export const checkContractVerified = tool({
+    description: "Check if a smart contract is verified on Etherscan.",
+    parameters: z.object({
+        address: z.string().describe(""),
+        chain: z.string().describe("").optional()
+    }),
+    execute: async (params) => fetchOracle('/chain/contract-verified', params)
+});
+
+export const getGasHistory = tool({
+    description: "Gas prices over last N blocks.",
+    parameters: z.object({
+        chain: z.string().describe("").optional(),
+        blocks: z.number().int().describe("").optional()
+    }),
+    execute: async (params) => fetchOracle('/chain/gas-history', params)
+});
+
+export const getBlockTime = tool({
+    description: "Get timestamp for any block number.",
+    parameters: z.object({
+        block: z.string().describe(""),
+        chain: z.string().describe("").optional()
+    }),
+    execute: async (params) => fetchOracle('/chain/block-time', params)
+});
+
+export const getActiveProposals = tool({
+    description: "Currently active voting proposals from major DAOs via Snapshot.",
+    parameters: z.object({}),
+    execute: async (params) => fetchOracle('/governance/active-proposals', params)
+});
+
+export const getDAOProposals = tool({
+    description: "Proposals for a specific DAO/space.",
+    parameters: z.object({
+        space: z.string().describe("")
+    }),
+    execute: async (params) => fetchOracle('/governance/dao-proposals', params)
+});
+
+export const getVotingPower = tool({
+    description: "Check voting power for an address in a specific DAO.",
+    parameters: z.object({
+        space: z.string().describe(""),
+        address: z.string().describe("")
+    }),
+    execute: async (params) => fetchOracle('/governance/voting-power', params)
+});
+
+export const getRecentVotes = tool({
+    description: "Recent voting events across DAOs.",
+    parameters: z.object({}),
+    execute: async (params) => fetchOracle('/governance/recent-votes', params)
+});
+
+export const getLensProfile = tool({
+    description: "Lens Protocol profile lookup.",
+    parameters: z.object({
+        handle: z.string().describe("")
+    }),
+    execute: async (params) => fetchOracle('/identity/lens-profile', params)
+});
+
+export const getFarcasterProfile = tool({
+    description: "Farcaster profile lookup.",
+    parameters: z.object({
+        username: z.string().describe("")
+    }),
+    execute: async (params) => fetchOracle('/identity/farcaster-profile', params)
+});
+
+export const getENSRecords = tool({
+    description: "Full ENS records: owner, expiry, avatar, text records.",
+    parameters: z.object({
+        name: z.string().describe("")
+    }),
+    execute: async (params) => fetchOracle('/identity/ens-records', params)
+});
+
+export const getAddressLabels = tool({
+    description: "Known labels for addresses: Exchange wallets, DEX routers.",
+    parameters: z.object({
+        address: z.string().describe("")
+    }),
+    execute: async (params) => fetchOracle('/identity/address-labels', params)
+});
+
+export const getPrice24hAgo = tool({
+    description: "Token price exactly 24 hours ago.",
+    parameters: z.object({
+        id: z.string().describe("")
+    }),
+    execute: async (params) => fetchOracle('/history/price-24h/{id}', params)
+});
+
+export const getPrice7dAgo = tool({
+    description: "Token price 7 days ago.",
+    parameters: z.object({
+        id: z.string().describe("")
+    }),
+    execute: async (params) => fetchOracle('/history/price-7d/{id}', params)
+});
+
+export const getPrice30dAgo = tool({
+    description: "Token price 30 days ago.",
+    parameters: z.object({
+        id: z.string().describe("")
+    }),
+    execute: async (params) => fetchOracle('/history/price-30d/{id}', params)
+});
+
+export const getOHLC30d = tool({
+    description: "Open-High-Low-Close data for 30 days.",
+    parameters: z.object({
+        id: z.string().describe("")
+    }),
+    execute: async (params) => fetchOracle('/history/ohlc-30d/{id}', params)
+});
+
+export const getVolume7d = tool({
+    description: "7 days of trading volume.",
+    parameters: z.object({
+        id: z.string().describe("")
+    }),
+    execute: async (params) => fetchOracle('/history/volume-7d/{id}', params)
+});
+
+export const getAgentRankings = tool({
+    description: "PROPRIETARY: Ranked list of most-called endpoints.",
+    parameters: z.object({}),
+    execute: async (params) => fetchOracle('/meta/agent-rankings', params)
+});
+
+export const getCategoryVelocity = tool({
+    description: "PROPRIETARY: 7-day growth rate by category.",
+    parameters: z.object({}),
+    execute: async (params) => fetchOracle('/meta/category-velocity', params)
+});
+
+export const getCorrelationMatrix = tool({
+    description: "PROPRIETARY: Which endpoints are queried together.",
+    parameters: z.object({}),
+    execute: async (params) => fetchOracle('/meta/correlation-matrix', params)
+});
+
+export const getHourlyVolume = tool({
+    description: "PROPRIETARY: 24-hour volume by hour.",
+    parameters: z.object({}),
+    execute: async (params) => fetchOracle('/meta/hourly-volume', params)
+});
+
+export const getErrorPatterns = tool({
+    description: "PROPRIETARY: Common error patterns across the network.",
+    parameters: z.object({}),
+    execute: async (params) => fetchOracle('/meta/error-patterns', params)
+});
+
+export const getTopCallers = tool({
+    description: "PROPRIETARY: Most active agent wallets.",
+    parameters: z.object({}),
+    execute: async (params) => fetchOracle('/meta/top-callers', params)
+});
+
+export const getEntrySignal = tool({
+    description: "SYNTHETIC: Buy signal 0-100. Contrarian entry timing.",
+    parameters: z.object({
+        id: z.string().describe("Token ID (default: bitcoin)").optional()
+    }),
+    execute: async (params) => fetchOracle('/alpha/entry-signal', params)
+});
+
+export const getExitSignal = tool({
+    description: "SYNTHETIC: Sell signal 0-100. Take profit timing.",
+    parameters: z.object({
+        id: z.string().describe("Token ID (default: bitcoin)").optional()
+    }),
+    execute: async (params) => fetchOracle('/alpha/exit-signal', params)
+});
+
+export const getDipDetector = tool({
+    description: "SYNTHETIC: Buy-the-dip trigger. Accumulation zone detector.",
+    parameters: z.object({
+        id: z.string().describe("Token ID (default: bitcoin)").optional()
+    }),
+    execute: async (params) => fetchOracle('/alpha/dip-detector', params)
+});
+
+export const getMomentumScore = tool({
+    description: "SYNTHETIC: Trend strength -100 to +100.",
+    parameters: z.object({
+        id: z.string().describe("Token ID (default: bitcoin)").optional()
+    }),
+    execute: async (params) => fetchOracle('/alpha/momentum-score', params)
+});
+
+export const getVolatilityRegime = tool({
+    description: "SYNTHETIC: Volatility state (Low/Normal/High/Extreme).",
+    parameters: z.object({
+        id: z.string().describe("Token ID (default: bitcoin)").optional()
+    }),
+    execute: async (params) => fetchOracle('/alpha/volatility-regime', params)
+});
+
+export const getSmartMoneyFlow = tool({
+    description: "SYNTHETIC: Stablecoin vs BTC ratio as smart money indicator.",
+    parameters: z.object({}),
+    execute: async (params) => fetchOracle('/alpha/smart-money-flow', params)
+});