x402-omni-oracle 0.1.0 → 0.1.1

package/src/index.ts

@@ -4,13 +4,15 @@ import { z } from 'zod';
 // Base URL for Omni-Oracle
 const BASE_URL = 'https://omni-oracle.omnioracle.workers.dev';
 
+// Response type for Oracle calls
+type OracleResponse = Record<string, unknown> | { error: string; message: string; price?: string | null; recipient?: string | null; endpoint?: string };
 
-async function fetchOracle(path: string, params: Record<string, any> = {}) {
+async function fetchOracle(path: string, params: Record<string, unknown> = {}): Promise<OracleResponse> {
     const url = new URL(`${BASE_URL}${path}`);
-    
+
     // Substitute path params
     let finalPath = path;
-    const queryParams: Record<string, any> = {};
+    const queryParams: Record<string, unknown> = {};
 
     for (const [key, value] of Object.entries(params)) {
         if (finalPath.includes(`{${key}}`)) {
@@ -19,7 +21,7 @@ async function fetchOracle(path: string, params: Record<string, any> = {}) {
             queryParams[key] = value;
         }
     }
-    
+
     url.pathname = finalPath;
     for (const [key, value] of Object.entries(queryParams)) {
         if (value !== undefined && value !== null) {
@@ -30,218 +32,180 @@ async function fetchOracle(path: string, params: Record<string, any> = {}) {
     try {
         const res = await fetch(url.toString());
         if (res.status === 200) {
-            return await res.json();
+            return await res.json() as Record<string, unknown>;
         } else if (res.status === 402) {
-             return {
+            const errorData = await res.json() as any;
+            if (errorData.accepts && errorData.accepts.length > 0) {
+                const offer = errorData.accepts[0];
+                return {
+                    error: 'PAYMENT_REQUIRED',
+                    type: 'CHALLENGE',
+                    message: `Payment Required. Price: ${offer.maxAmountRequired} (units). Send to ${offer.payTo} on ${offer.network}.`,
+                    payment_instructions: {
+                        price_usdc: parseInt(offer.maxAmountRequired) / 1000000,
+                        pay_to: offer.payTo,
+                        network: offer.network,
+                        description: offer.description
+                    },
+                    hint: "Sign a transaction and retry this tool call with header 'X-402-Payment-Hash'."
+                };
+            }
+            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
+                message: 'This endpoint requires payment. Please check server accepts headers.'
             };
         } else {
             return { error: `HTTP ${res.status}`, message: await res.text() };
         }
-    } catch (e: any) {
-        return { error: 'CONNECTION_ERROR', message: e.message };
+    } catch (e: unknown) {
+        return { error: 'CONNECTION_ERROR', message: e instanceof Error ? e.message : 'Unknown error' };
     }
 }
 
 
 export const getKLAXThermalRisk = tool({
-    description: "Aviation weather and thermal risk data for Los Angeles International Airport.",
+    description: "Need to route cargo through LAX? Use this endpoint to get deterministic thermal risk scores and visibility metrics. Essential for calculating flight delays and supply chain routing.",
     parameters: z.object({}),
-    execute: async (params) => fetchOracle('/logistics/klax', params)
+    execute: async () => fetchOracle('/logistics/klax', {})
 });
 
 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)
+    execute: async () => fetchOracle('/logistics/kjfk', {})
 });
 
 export const getKMEMThermalRisk = tool({
     description: "Aviation weather for Memphis International (FedEx SuperHub).",
     parameters: z.object({}),
-    execute: async (params) => fetchOracle('/logistics/kmem', params)
+    execute: async () => fetchOracle('/logistics/kmem', {})
 });
 
 export const getKORDThermalRisk = tool({
     description: "Aviation weather for Chicago O'Hare International Airport.",
     parameters: z.object({}),
-    execute: async (params) => fetchOracle('/logistics/kord', params)
+    execute: async () => fetchOracle('/logistics/kord', {})
 });
 
 export const getKIAHThermalRisk = tool({
     description: "Aviation weather for George Bush Intercontinental Airport.",
     parameters: z.object({}),
-    execute: async (params) => fetchOracle('/logistics/kiah', params)
+    execute: async () => fetchOracle('/logistics/kiah', {})
 });
 
 export const getLHRThermalRisk = tool({
     description: "Aviation weather for London Heathrow. Europe gateway risk.",
     parameters: z.object({}),
-    execute: async (params) => fetchOracle('/logistics/lhr', params)
+    execute: async () => fetchOracle('/logistics/lhr', {})
 });
 
 export const getHNDThermalRisk = tool({
     description: "Aviation weather for Tokyo Haneda. Asia gateway risk.",
     parameters: z.object({}),
-    execute: async (params) => fetchOracle('/logistics/hnd', params)
+    execute: async () => fetchOracle('/logistics/hnd', {})
 });
 
 export const getDXBThermalRisk = tool({
     description: "Aviation weather for Dubai Intl. Middle East hub risk.",
     parameters: z.object({}),
-    execute: async (params) => fetchOracle('/logistics/dxb', params)
+    execute: async () => fetchOracle('/logistics/dxb', {})
 });
 
 export const getHKGThermalRisk = tool({
     description: "Aviation weather for Hong Kong. Global Air Cargo hub.",
     parameters: z.object({}),
-    execute: async (params) => fetchOracle('/logistics/hkg', params)
+    execute: async () => fetchOracle('/logistics/hkg', {})
 });
 
 export const getFRAThermalRisk = tool({
     description: "Aviation weather for Frankfurt. Europe cargo hub.",
     parameters: z.object({}),
-    execute: async (params) => fetchOracle('/logistics/fra', params)
+    execute: async () => fetchOracle('/logistics/fra', {})
 });
 
 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.",
+    description: "Optimize AI training or mining for carbon efficiency. Returns a `green_window` boolean when grid carbon intensity is <300g/kWh, allowing you to pause/resume workloads.",
     parameters: z.object({}),
-    execute: async (params) => fetchOracle('/compute/green-window', params)
+    execute: async () => fetchOracle('/compute/green-window', {})
 });
 
 export const getJupiterQuote = tool({
-    description: "Get optimal swap route from Jupiter Aggregator v6 on Solana.",
+    description: "Perform best-price execution on Solana. Returns optimal routing, price impact, and fee structure via Jupiter v6. Use this before executing any text-to-trade command.",
     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)
+    execute: async (args) => fetchOracle('/finance/jupiter/quote', args)
 });
 
 export const getCoinGeckoPrice = tool({
-    description: "Real-time USD price from CoinGecko with 24h change and volatility triggers.",
+    description: "Get reliable crypto spot prices in USD. Access 10,000+ assets with no rate limits. Includes volatility data to help you decide when to trade.",
     parameters: z.object({
         id: z.string().describe("CoinGecko token ID")
     }),
-    execute: async (params) => fetchOracle('/finance/coingecko/price/{id}', params)
+    execute: async (args) => fetchOracle('/finance/coingecko/price/{id}', args)
 });
 
 export const getCoinGeckoTrending = tool({
     description: "Top 10 trending tokens on CoinGecko.",
     parameters: z.object({}),
-    execute: async (params) => fetchOracle('/finance/coingecko/trending', params)
+    execute: async () => fetchOracle('/finance/coingecko/trending', {})
 });
 
 export const getGlobalMarketStats = tool({
     description: "Total market cap, volume, and BTC/ETH dominance.",
     parameters: z.object({}),
-    execute: async (params) => fetchOracle('/finance/coingecko/global', params)
+    execute: async () => fetchOracle('/finance/coingecko/global', {})
 });
 
-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)
+    execute: async () => fetchOracle('/crypto/congestion/fees', {})
 });
 
 export const getBitcoinBlockStatus = tool({
     description: "Latest block height from Mempool.space.",
     parameters: z.object({}),
-    execute: async (params) => fetchOracle('/crypto/btc/block-status', params)
+    execute: async () => fetchOracle('/crypto/congestion/block-status', {})
 });
 
 export const getEthereumGas = tool({
     description: "Real-time Gas (Wei) from Beaconcha.in.",
     parameters: z.object({}),
-    execute: async (params) => fetchOracle('/crypto/eth/gas-forecast', params)
+    execute: async () => fetchOracle('/gas/optimize/gas-forecast', {})
 });
 
-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)
+    execute: async () => fetchOracle('/risk/seismic/recent', {})
 });
 
 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)
+    execute: async () => fetchOracle('/risk/solar/storm-alert', {})
 });
 
 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)
+    execute: async () => fetchOracle('/risk/market-crash-probability', {})
 });
 
 export const getHackerNewsTopStories = tool({
     description: "Top 10 trending stories from HackerNews.",
     parameters: z.object({}),
-    execute: async (params) => fetchOracle('/sentiment/hn/top-stories', params)
+    execute: async () => fetchOracle('/sentiment/hn/top-stories', {})
 });
 
 export const searchHackerNews = tool({
@@ -249,13 +213,13 @@ export const searchHackerNews = tool({
     parameters: z.object({
         query: z.string().describe("")
     }),
-    execute: async (params) => fetchOracle('/sentiment/hn/keyword/{query}', params)
+    execute: async (args) => fetchOracle('/sentiment/hn/keyword/{query}', args)
 });
 
 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)
+    execute: async () => fetchOracle('/sentiment/arxiv/daily/ai', {})
 });
 
 export const searchArXiv = tool({
@@ -263,102 +227,27 @@ export const searchArXiv = tool({
     parameters: z.object({
         q: z.string().describe("")
     }),
-    execute: async (params) => fetchOracle('/sentiment/arxiv/search', params)
+    execute: async (args) => fetchOracle('/sentiment/arxiv/search', args)
 });
 
 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)
+    execute: async () => fetchOracle('/sentiment/feargreed/index', {})
 });
 
 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)
+    execute: async () => fetchOracle('/sentiment/feargreed/history', {})
 });
 
-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)
+    execute: async () => fetchOracle('/identity/whoami', {})
 });
 
 export const getReputationScore = tool({
@@ -366,19 +255,19 @@ export const getReputationScore = tool({
     parameters: z.object({
         address: z.string().describe("")
     }),
-    execute: async (params) => fetchOracle('/identity/score/{address}', params)
+    execute: async (args) => fetchOracle('/identity/score/{address}', args)
 });
 
 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)
+    execute: async () => fetchOracle('/meta/pulse', {})
 });
 
 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)
+    execute: async () => fetchOracle('/meta/sentiment', {})
 });
 
 export const getTokenMetadata = tool({
@@ -386,13 +275,13 @@ export const getTokenMetadata = tool({
     parameters: z.object({
         address: z.string().describe("")
     }),
-    execute: async (params) => fetchOracle('/token/metadata/{address}', params)
+    execute: async (args) => fetchOracle('/token/metadata/{address}', args)
 });
 
 export const getWhaleMovements = tool({
     description: "Large transfers (> $1M) detected in the last hour.",
     parameters: z.object({}),
-    execute: async (params) => fetchOracle('/whale/recent', params)
+    execute: async () => fetchOracle('/whale/recent', {})
 });
 
 export const resolveENS = tool({
@@ -400,7 +289,7 @@ export const resolveENS = tool({
     parameters: z.object({
         name: z.string().describe("")
     }),
-    execute: async (params) => fetchOracle('/ens/resolve/{name}', params)
+    execute: async (args) => fetchOracle('/ens/resolve/{name}', args)
 });
 
 export const getBlockData = tool({
@@ -408,7 +297,7 @@ export const getBlockData = tool({
     parameters: z.object({
         height: z.string().describe("")
     }),
-    execute: async (params) => fetchOracle('/chain/block/{height}', params)
+    execute: async (args) => fetchOracle('/chain/block/{height}', args)
 });
 
 export const checkAirdropEligibility = tool({
@@ -416,7 +305,7 @@ export const checkAirdropEligibility = tool({
     parameters: z.object({
         address: z.string().describe("")
     }),
-    execute: async (params) => fetchOracle('/airdrop/check/{address}', params)
+    execute: async (args) => fetchOracle('/airdrop/check/{address}', args)
 });
 
 export const getTradePreflight = tool({
@@ -424,7 +313,7 @@ export const getTradePreflight = tool({
     parameters: z.object({
         token: z.string().describe("")
     }),
-    execute: async (params) => fetchOracle('/preflight/trade', params)
+    execute: async (args) => fetchOracle('/preflight/trade', args)
 });
 
 export const getWalletValues = tool({
@@ -432,218 +321,159 @@ export const getWalletValues = tool({
     parameters: z.object({
         address: z.string().describe("")
     }),
-    execute: async (params) => fetchOracle('/preflight/wallet', params)
+    execute: async (args) => fetchOracle('/preflight/wallet', args)
 });
 
-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)
+    execute: async (args) => fetchOracle('/price/batch', args)
 });
 
-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)
+    execute: async () => fetchOracle('/.well-known/x402-bazaar', {})
 });
 
 export const getOpenAPISpec = tool({
     description: "This OpenAPI 3.1 specification.",
     parameters: z.object({}),
-    execute: async (params) => fetchOracle('/doc', params)
+    execute: async () => fetchOracle('/doc', {})
+});
+
+export const getPublicStatus = tool({
+    description: "FREE: Public system status dashboard. Returns 24h request count, avg latency, uptime %, and top categories. No payment required.",
+    parameters: z.object({}),
+    execute: async () => fetchOracle('/public/status', {})
+});
+
+export const getSystemPrompt = tool({
+    description: "FREE: Returns the 'Capability Patch' system prompt. Agents should read this if they encounter 402 Payment Required errors to learn the payment flow.",
+    parameters: z.object({}),
+    execute: async () => fetchOracle('/system_prompt', {})
 });
 
 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)
+    execute: async () => fetchOracle('/alpha/market-regime', {})
 });
 
 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)
+    execute: async () => fetchOracle('/alpha/whale-momentum', {})
 });
 
 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)
+    execute: async () => fetchOracle('/alpha/sentiment-divergence', {})
 });
 
 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)
+    execute: async () => fetchOracle('/alpha/risk-adjusted-yield', {})
 });
 
 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)
+    execute: async () => fetchOracle('/meta/trending-queries', {})
 });
 
 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)
+    execute: async () => fetchOracle('/meta/sector-rotation', {})
 });
 
 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)
+    execute: async () => fetchOracle('/meta/anomaly-alert', {})
 });
 
 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)
+    execute: async () => fetchOracle('/meta/consensus', {})
 });
 
 export const getSINThermalRisk = tool({
     description: "NOAA Aviation Weather for Singapore Changi. Asia-Pacific hub.",
     parameters: z.object({}),
-    execute: async (params) => fetchOracle('/logistics/sin', params)
+    execute: async () => fetchOracle('/logistics/sin', {})
 });
 
 export const getPEKThermalRisk = tool({
     description: "NOAA Aviation Weather for Beijing Capital. China gateway.",
     parameters: z.object({}),
-    execute: async (params) => fetchOracle('/logistics/pek', params)
+    execute: async () => fetchOracle('/logistics/pek', {})
 });
 
 export const getCDGThermalRisk = tool({
     description: "NOAA Aviation Weather for Paris Charles de Gaulle.",
     parameters: z.object({}),
-    execute: async (params) => fetchOracle('/logistics/cdg', params)
+    execute: async () => fetchOracle('/logistics/cdg', {})
 });
 
 export const getAMSThermalRisk = tool({
     description: "NOAA Aviation Weather for Amsterdam Schiphol.",
     parameters: z.object({}),
-    execute: async (params) => fetchOracle('/logistics/ams', params)
+    execute: async () => fetchOracle('/logistics/ams', {})
 });
 
 export const getICNThermalRisk = tool({
     description: "NOAA Aviation Weather for Seoul Incheon.",
     parameters: z.object({}),
-    execute: async (params) => fetchOracle('/logistics/icn', params)
+    execute: async () => fetchOracle('/logistics/icn', {})
 });
 
 export const getSYDThermalRisk = tool({
     description: "NOAA Aviation Weather for Sydney Kingsford Smith.",
     parameters: z.object({}),
-    execute: async (params) => fetchOracle('/logistics/syd', params)
+    execute: async () => fetchOracle('/logistics/syd', {})
 });
 
 export const getGRUThermalRisk = tool({
     description: "NOAA Aviation Weather for São Paulo Guarulhos.",
     parameters: z.object({}),
-    execute: async (params) => fetchOracle('/logistics/gru', params)
+    execute: async () => fetchOracle('/logistics/gru', {})
 });
 
 export const getBOMThermalRisk = tool({
     description: "NOAA Aviation Weather for Mumbai Chhatrapati Shivaji.",
     parameters: z.object({}),
-    execute: async (params) => fetchOracle('/logistics/bom', params)
+    execute: async () => fetchOracle('/logistics/bom', {})
 });
 
 export const getJNBThermalRisk = tool({
     description: "NOAA Aviation Weather for Johannesburg O.R. Tambo.",
     parameters: z.object({}),
-    execute: async (params) => fetchOracle('/logistics/jnb', params)
+    execute: async () => fetchOracle('/logistics/jnb', {})
 });
 
 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)
+    execute: async () => fetchOracle('/logistics/mex', {})
 });
 
-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)
+    execute: async () => fetchOracle('/token/unlocks', {})
 });
 
 export const getTokenSupply = tool({
@@ -651,7 +481,7 @@ export const getTokenSupply = tool({
     parameters: z.object({
         id: z.string().describe("")
     }),
-    execute: async (params) => fetchOracle('/token/supply/{id}', params)
+    execute: async (args) => fetchOracle('/token/supply/{id}', args)
 });
 
 export const getTokenATHATL = tool({
@@ -659,7 +489,7 @@ export const getTokenATHATL = tool({
     parameters: z.object({
         id: z.string().describe("")
     }),
-    execute: async (params) => fetchOracle('/token/ath-atl/{id}', params)
+    execute: async (args) => fetchOracle('/token/ath-atl/{id}', args)
 });
 
 export const getTokenCategories = tool({
@@ -667,7 +497,7 @@ export const getTokenCategories = tool({
     parameters: z.object({
         id: z.string().describe("")
     }),
-    execute: async (params) => fetchOracle('/token/categories/{id}', params)
+    execute: async (args) => fetchOracle('/token/categories/{id}', args)
 });
 
 export const getTokenExchanges = tool({
@@ -675,7 +505,7 @@ export const getTokenExchanges = tool({
     parameters: z.object({
         id: z.string().describe("")
     }),
-    execute: async (params) => fetchOracle('/token/exchanges/{id}', params)
+    execute: async (args) => fetchOracle('/token/exchanges/{id}', args)
 });
 
 export const getProtocolsByChain = tool({
@@ -683,7 +513,7 @@ export const getProtocolsByChain = tool({
     parameters: z.object({
         chain: z.string().describe("")
     }),
-    execute: async (params) => fetchOracle('/defi/protocols-by-chain', params)
+    execute: async (args) => fetchOracle('/defi/protocols-by-chain', args)
 });
 
 export const getTVLChange = tool({
@@ -691,7 +521,7 @@ export const getTVLChange = tool({
     parameters: z.object({
         protocol: z.string().describe("").optional()
     }),
-    execute: async (params) => fetchOracle('/defi/tvl-change', params)
+    execute: async (args) => fetchOracle('/defi/tvl-change', args)
 });
 
 export const getLendingRates = tool({
@@ -699,19 +529,19 @@ export const getLendingRates = tool({
     parameters: z.object({
         token: z.string().describe("").optional()
     }),
-    execute: async (params) => fetchOracle('/defi/lending-rates', params)
+    execute: async (args) => fetchOracle('/defi/lending-rates', args)
 });
 
 export const getStakingYields = tool({
     description: "Native staking APYs for ETH, SOL, ATOM, etc.",
     parameters: z.object({}),
-    execute: async (params) => fetchOracle('/defi/staking-yields', params)
+    execute: async () => fetchOracle('/defi/staking-yields', {})
 });
 
 export const getDeFiLiquidations = tool({
     description: "Recent liquidation events and at-risk capital.",
     parameters: z.object({}),
-    execute: async (params) => fetchOracle('/defi/liquidations', params)
+    execute: async () => fetchOracle('/defi/liquidations', {})
 });
 
 export const getDeFiHacks = tool({
@@ -719,13 +549,13 @@ export const getDeFiHacks = tool({
     parameters: z.object({
         days: z.number().int().describe("").optional()
     }),
-    execute: async (params) => fetchOracle('/defi/hacks', params)
+    execute: async (args) => fetchOracle('/defi/hacks', args)
 });
 
 export const getBridgesTVL = tool({
     description: "Cross-chain bridge TVL and volume.",
     parameters: z.object({}),
-    execute: async (params) => fetchOracle('/defi/bridges-tvl', params)
+    execute: async () => fetchOracle('/defi/bridges-tvl', {})
 });
 
 export const getDEXVolume = tool({
@@ -733,7 +563,7 @@ export const getDEXVolume = tool({
     parameters: z.object({
         chain: z.string().describe("").optional()
     }),
-    execute: async (params) => fetchOracle('/defi/dex-volume', params)
+    execute: async (args) => fetchOracle('/defi/dex-volume', args)
 });
 
 export const getFundingRates = tool({
@@ -741,7 +571,7 @@ export const getFundingRates = tool({
     parameters: z.object({
         symbol: z.string().describe("").optional()
     }),
-    execute: async (params) => fetchOracle('/derivatives/funding-rates', params)
+    execute: async (args) => fetchOracle('/derivatives/funding-rates', args)
 });
 
 export const getOpenInterest = tool({
@@ -749,7 +579,7 @@ export const getOpenInterest = tool({
     parameters: z.object({
         symbol: z.string().describe("")
     }),
-    execute: async (params) => fetchOracle('/derivatives/open-interest', params)
+    execute: async (args) => fetchOracle('/derivatives/open-interest', args)
 });
 
 export const getLongShortRatio = tool({
@@ -757,7 +587,7 @@ export const getLongShortRatio = tool({
     parameters: z.object({
         symbol: z.string().describe("")
     }),
-    execute: async (params) => fetchOracle('/derivatives/long-short-ratio', params)
+    execute: async (args) => fetchOracle('/derivatives/long-short-ratio', args)
 });
 
 export const getTopTraders = tool({
@@ -765,7 +595,7 @@ export const getTopTraders = tool({
     parameters: z.object({
         symbol: z.string().describe("")
     }),
-    execute: async (params) => fetchOracle('/derivatives/top-traders', params)
+    execute: async (args) => fetchOracle('/derivatives/top-traders', args)
 });
 
 export const getDerivativesLiquidations = tool({
@@ -773,7 +603,7 @@ export const getDerivativesLiquidations = tool({
     parameters: z.object({
         symbol: z.string().describe("").optional()
     }),
-    execute: async (params) => fetchOracle('/derivatives/liquidations', params)
+    execute: async (args) => fetchOracle('/derivatives/liquidations', args)
 });
 
 export const lookupTransaction = tool({
@@ -782,7 +612,7 @@ export const lookupTransaction = tool({
         hash: z.string().describe(""),
         chain: z.string().describe("").optional()
     }),
-    execute: async (params) => fetchOracle('/chain/tx-lookup', params)
+    execute: async (args) => fetchOracle('/chain/tx-lookup', args)
 });
 
 export const getAddressBalance = tool({
@@ -791,7 +621,7 @@ export const getAddressBalance = tool({
         address: z.string().describe(""),
         chain: z.string().describe("").optional()
     }),
-    execute: async (params) => fetchOracle('/chain/address-balance', params)
+    execute: async (args) => fetchOracle('/chain/address-balance', args)
 });
 
 export const getTokenBalances = tool({
@@ -800,7 +630,7 @@ export const getTokenBalances = tool({
         address: z.string().describe(""),
         chain: z.string().describe("").optional()
     }),
-    execute: async (params) => fetchOracle('/chain/token-balances', params)
+    execute: async (args) => fetchOracle('/chain/token-balances', args)
 });
 
 export const checkContractVerified = tool({
@@ -809,7 +639,7 @@ export const checkContractVerified = tool({
         address: z.string().describe(""),
         chain: z.string().describe("").optional()
     }),
-    execute: async (params) => fetchOracle('/chain/contract-verified', params)
+    execute: async (args) => fetchOracle('/chain/contract-verified', args)
 });
 
 export const getGasHistory = tool({
@@ -818,7 +648,7 @@ export const getGasHistory = tool({
         chain: z.string().describe("").optional(),
         blocks: z.number().int().describe("").optional()
     }),
-    execute: async (params) => fetchOracle('/chain/gas-history', params)
+    execute: async (args) => fetchOracle('/chain/gas-history', args)
 });
 
 export const getBlockTime = tool({
@@ -827,13 +657,13 @@ export const getBlockTime = tool({
         block: z.string().describe(""),
         chain: z.string().describe("").optional()
     }),
-    execute: async (params) => fetchOracle('/chain/block-time', params)
+    execute: async (args) => fetchOracle('/chain/block-time', args)
 });
 
 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)
+    execute: async () => fetchOracle('/governance/active-proposals', {})
 });
 
 export const getDAOProposals = tool({
@@ -841,7 +671,7 @@ export const getDAOProposals = tool({
     parameters: z.object({
         space: z.string().describe("")
     }),
-    execute: async (params) => fetchOracle('/governance/dao-proposals', params)
+    execute: async (args) => fetchOracle('/governance/dao-proposals', args)
 });
 
 export const getVotingPower = tool({
@@ -850,13 +680,13 @@ export const getVotingPower = tool({
         space: z.string().describe(""),
         address: z.string().describe("")
     }),
-    execute: async (params) => fetchOracle('/governance/voting-power', params)
+    execute: async (args) => fetchOracle('/governance/voting-power', args)
 });
 
 export const getRecentVotes = tool({
     description: "Recent voting events across DAOs.",
     parameters: z.object({}),
-    execute: async (params) => fetchOracle('/governance/recent-votes', params)
+    execute: async () => fetchOracle('/governance/recent-votes', {})
 });
 
 export const getLensProfile = tool({
@@ -864,7 +694,7 @@ export const getLensProfile = tool({
     parameters: z.object({
         handle: z.string().describe("")
     }),
-    execute: async (params) => fetchOracle('/identity/lens-profile', params)
+    execute: async (args) => fetchOracle('/identity/lens-profile', args)
 });
 
 export const getFarcasterProfile = tool({
@@ -872,7 +702,7 @@ export const getFarcasterProfile = tool({
     parameters: z.object({
         username: z.string().describe("")
     }),
-    execute: async (params) => fetchOracle('/identity/farcaster-profile', params)
+    execute: async (args) => fetchOracle('/identity/farcaster-profile', args)
 });
 
 export const getENSRecords = tool({
@@ -880,7 +710,7 @@ export const getENSRecords = tool({
     parameters: z.object({
         name: z.string().describe("")
     }),
-    execute: async (params) => fetchOracle('/identity/ens-records', params)
+    execute: async (args) => fetchOracle('/identity/ens-records', args)
 });
 
 export const getAddressLabels = tool({
@@ -888,7 +718,7 @@ export const getAddressLabels = tool({
     parameters: z.object({
         address: z.string().describe("")
     }),
-    execute: async (params) => fetchOracle('/identity/address-labels', params)
+    execute: async (args) => fetchOracle('/identity/address-labels', args)
 });
 
 export const getPrice24hAgo = tool({
@@ -896,7 +726,7 @@ export const getPrice24hAgo = tool({
     parameters: z.object({
         id: z.string().describe("")
     }),
-    execute: async (params) => fetchOracle('/history/price-24h/{id}', params)
+    execute: async (args) => fetchOracle('/history/price-24h/{id}', args)
 });
 
 export const getPrice7dAgo = tool({
@@ -904,7 +734,7 @@ export const getPrice7dAgo = tool({
     parameters: z.object({
         id: z.string().describe("")
     }),
-    execute: async (params) => fetchOracle('/history/price-7d/{id}', params)
+    execute: async (args) => fetchOracle('/history/price-7d/{id}', args)
 });
 
 export const getPrice30dAgo = tool({
@@ -912,7 +742,7 @@ export const getPrice30dAgo = tool({
     parameters: z.object({
         id: z.string().describe("")
     }),
-    execute: async (params) => fetchOracle('/history/price-30d/{id}', params)
+    execute: async (args) => fetchOracle('/history/price-30d/{id}', args)
 });
 
 export const getOHLC30d = tool({
@@ -920,7 +750,7 @@ export const getOHLC30d = tool({
     parameters: z.object({
         id: z.string().describe("")
     }),
-    execute: async (params) => fetchOracle('/history/ohlc-30d/{id}', params)
+    execute: async (args) => fetchOracle('/history/ohlc-30d/{id}', args)
 });
 
 export const getVolume7d = tool({
@@ -928,43 +758,43 @@ export const getVolume7d = tool({
     parameters: z.object({
         id: z.string().describe("")
     }),
-    execute: async (params) => fetchOracle('/history/volume-7d/{id}', params)
+    execute: async (args) => fetchOracle('/history/volume-7d/{id}', args)
 });
 
 export const getAgentRankings = tool({
     description: "PROPRIETARY: Ranked list of most-called endpoints.",
     parameters: z.object({}),
-    execute: async (params) => fetchOracle('/meta/agent-rankings', params)
+    execute: async () => fetchOracle('/meta/agent-rankings', {})
 });
 
 export const getCategoryVelocity = tool({
     description: "PROPRIETARY: 7-day growth rate by category.",
     parameters: z.object({}),
-    execute: async (params) => fetchOracle('/meta/category-velocity', params)
+    execute: async () => fetchOracle('/meta/category-velocity', {})
 });
 
 export const getCorrelationMatrix = tool({
     description: "PROPRIETARY: Which endpoints are queried together.",
     parameters: z.object({}),
-    execute: async (params) => fetchOracle('/meta/correlation-matrix', params)
+    execute: async () => fetchOracle('/meta/correlation-matrix', {})
 });
 
 export const getHourlyVolume = tool({
     description: "PROPRIETARY: 24-hour volume by hour.",
     parameters: z.object({}),
-    execute: async (params) => fetchOracle('/meta/hourly-volume', params)
+    execute: async () => fetchOracle('/meta/hourly-volume', {})
 });
 
 export const getErrorPatterns = tool({
     description: "PROPRIETARY: Common error patterns across the network.",
     parameters: z.object({}),
-    execute: async (params) => fetchOracle('/meta/error-patterns', params)
+    execute: async () => fetchOracle('/meta/error-patterns', {})
 });
 
 export const getTopCallers = tool({
     description: "PROPRIETARY: Most active agent wallets.",
     parameters: z.object({}),
-    execute: async (params) => fetchOracle('/meta/top-callers', params)
+    execute: async () => fetchOracle('/meta/top-callers', {})
 });
 
 export const getEntrySignal = tool({
@@ -972,7 +802,7 @@ export const getEntrySignal = tool({
     parameters: z.object({
         id: z.string().describe("Token ID (default: bitcoin)").optional()
     }),
-    execute: async (params) => fetchOracle('/alpha/entry-signal', params)
+    execute: async (args) => fetchOracle('/alpha/entry-signal', args)
 });
 
 export const getExitSignal = tool({
@@ -980,7 +810,7 @@ export const getExitSignal = tool({
     parameters: z.object({
         id: z.string().describe("Token ID (default: bitcoin)").optional()
     }),
-    execute: async (params) => fetchOracle('/alpha/exit-signal', params)
+    execute: async (args) => fetchOracle('/alpha/exit-signal', args)
 });
 
 export const getDipDetector = tool({
@@ -988,7 +818,7 @@ export const getDipDetector = tool({
     parameters: z.object({
         id: z.string().describe("Token ID (default: bitcoin)").optional()
     }),
-    execute: async (params) => fetchOracle('/alpha/dip-detector', params)
+    execute: async (args) => fetchOracle('/alpha/dip-detector', args)
 });
 
 export const getMomentumScore = tool({
@@ -996,7 +826,7 @@ export const getMomentumScore = tool({
     parameters: z.object({
         id: z.string().describe("Token ID (default: bitcoin)").optional()
     }),
-    execute: async (params) => fetchOracle('/alpha/momentum-score', params)
+    execute: async (args) => fetchOracle('/alpha/momentum-score', args)
 });
 
 export const getVolatilityRegime = tool({
@@ -1004,11 +834,11 @@ export const getVolatilityRegime = tool({
     parameters: z.object({
         id: z.string().describe("Token ID (default: bitcoin)").optional()
     }),
-    execute: async (params) => fetchOracle('/alpha/volatility-regime', params)
+    execute: async (args) => fetchOracle('/alpha/volatility-regime', args)
 });
 
 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)
+    execute: async () => fetchOracle('/alpha/smart-money-flow', {})
 });