@quantoracle/agentkit 0.1.0

package/README.md

@@ -0,0 +1,120 @@
+# QuantOracle for Coinbase AgentKit
+
+Deterministic quant finance math for autonomous agents built with [Coinbase AgentKit](https://github.com/coinbase/agentkit).
+
+> 📖 **Read the full integration comparison:** [AgentKit vs LangChain vs Direct HTTP — picking the right integration for paid agent APIs](https://dev.to/quantoracle/agentkit-vs-langchain-vs-direct-http-picking-the-right-integration-for-paid-agent-apis-2582) (dev.to, May 2026)
+
+> **Why this exists:** AI agents trying to compute Black-Scholes prices, Kelly fractions, or Monte Carlo simulations in-context drift. The numbers are wrong, the Greeks are hallucinated, and the agent can't tell. QuantOracle is grounded math: same inputs, same outputs, every time. Free tier covers calculator endpoints; paid composites (full risk audit, hedge recommendations) settle automatically via your AgentKit wallet using x402 micropayments on Base or Solana.
+
+## What this provides
+
+5 high-leverage actions covering the financial decisions an autonomous trading or finance agent typically faces:
+
+| Action | What it does | Cost |
+|---|---|---|
+| `price_option` | Black-Scholes pricing with full Greeks (delta, gamma, vega, theta, rho) | Free |
+| `calculate_kelly` | Kelly Criterion optimal sizing (full / half / quarter Kelly) | Free |
+| `simulate_portfolio` | Monte Carlo simulation with contributions, withdrawals, probability of ruin | Free |
+| `assess_portfolio_risk` | Composite audit: Sharpe, Sortino, Calmar, max DD, VaR, CVaR, Kelly, Hurst | $0.04 USDC via x402 |
+| `recommend_hedge` | Ranked hedge structures (collar, protective put, partial put, inverse) for any position | $0.04 USDC via x402 |
+
+The full QuantOracle API has 73 endpoints; this provider exposes a curated subset. For the long tail (exotic options, FX models, technical indicators, etc.), agents can call the raw API at `https://api.quantoracle.dev/v1/*` directly.
+
+## Free tier
+
+- **1,000 calls per IP per day**, no signup, no API key
+- Covers `price_option`, `calculate_kelly`, `simulate_portfolio` for almost any agent
+- Resets daily at 00:00 UTC
+
+## Paid endpoints (x402)
+
+`assess_portfolio_risk` and `recommend_hedge` are composite endpoints that wrap 5-15 calculator calls into a single response. They cost $0.04 USDC each, settled on-chain via the [x402 protocol](https://github.com/coinbase/x402) on Base mainnet or Solana mainnet.
+
+**Your AgentKit wallet handles payment automatically.** No API key, no signup, no billing setup. The wallet just needs to hold a small amount of USDC on Base or Solana.
+
+## Installation
+
+The action provider files live alongside your AgentKit project:
+
+```bash
+# 1. Create a new AgentKit project (or use an existing one)
+npx create-onchain-agent
+
+# 2. Copy the QuantOracle action provider files into your project
+mkdir -p src/quantoracle
+curl -sL https://raw.githubusercontent.com/QuantOracledev/quantoracle/main/integrations/agentkit/quantoracleActionProvider.ts -o src/quantoracle/quantoracleActionProvider.ts
+curl -sL https://raw.githubusercontent.com/QuantOracledev/quantoracle/main/integrations/agentkit/schemas.ts -o src/quantoracle/schemas.ts
+curl -sL https://raw.githubusercontent.com/QuantOracledev/quantoracle/main/integrations/agentkit/constants.ts -o src/quantoracle/constants.ts
+curl -sL https://raw.githubusercontent.com/QuantOracledev/quantoracle/main/integrations/agentkit/index.ts -o src/quantoracle/index.ts
+```
+
+Or clone the QuantOracle repo and copy the directory:
+
+```bash
+git clone https://github.com/QuantOracledev/quantoracle
+cp -r quantoracle/integrations/agentkit ./src/quantoracle
+```
+
+## Usage
+
+```ts
+import { AgentKit, CdpEvmWalletProvider } from "@coinbase/agentkit";
+import { quantoracleActionProvider } from "./quantoracle";
+
+const walletProvider = await CdpEvmWalletProvider.configureWithWallet({
+  apiKeyId: process.env.CDP_API_KEY_ID!,
+  apiKeySecret: process.env.CDP_API_KEY_SECRET!,
+  networkId: "base-mainnet",
+});
+
+const agentkit = await AgentKit.from({
+  walletProvider,
+  actionProviders: [quantoracleActionProvider()],
+});
+
+// The agent now has 5 new actions:
+//   price_option, calculate_kelly, simulate_portfolio,
+//   assess_portfolio_risk, recommend_hedge
+```
+
+A complete runnable example is at [`example-agent.ts`](./example-agent.ts). Additional examples:
+
+- [`example-agent-solana.ts`](./example-agent-solana.ts) — Same agent but routes x402 payments through a Solana mainnet wallet (SPL USDC) instead of Base. Useful for agents already operating in the Solana ecosystem.
+- [`example-chained-workflow.ts`](./example-chained-workflow.ts) — Scripted demo showing the natural `assess_portfolio_risk` → `recommend_hedge` chained workflow. Pre-baked prompts walk the agent through risk audit → hedge analysis → final recommendation. Spends ~$0.08 USDC per run on real x402 settlements.
+
+For a side-by-side comparison of integration patterns (direct HTTP vs AgentKit vs LangChain Python), see [`COMPARISONS.md`](./COMPARISONS.md).
+
+## Example agent prompts
+
+Try these in your AgentKit chat:
+
+- _"Price a 30-day NVDA call with strike $185, spot $180, 28% IV"_ → uses `price_option`
+- _"I have 55% win rate, $150 avg win, $100 avg loss — what's my Kelly?"_ → uses `calculate_kelly`
+- _"Simulate $100K over 30 years with 7% return, 16% vol, 4% withdrawal"_ → uses `simulate_portfolio`
+- _"Audit risk on my last 252 daily returns: [...]"_ → uses `assess_portfolio_risk` (paid)
+- _"Recommend hedges for my $100K long NVDA position over 30 days"_ → uses `recommend_hedge` (paid)
+
+## Try without code
+
+15 free interactive calculators backed by the same engine are at **[quantoracle.dev](https://quantoracle.dev)** — useful for verifying outputs before wiring the action provider into your agent.
+
+## Why deterministic finance math matters for agents
+
+Three failure modes when LLMs do financial math in-context:
+
+1. **Black-Scholes calculations drift.** GPT-4o's Greeks are wrong by 5-30% depending on moneyness. The agent can't tell.
+2. **Compound interest computations skip steps.** A 30-year projection at 8% loses meaningful precision over many tokens.
+3. **Kelly and VaR formulas are mis-applied.** LLMs often confuse arithmetic vs geometric returns or fail to annualize correctly.
+
+Grounded tools fix all three: the API is bytes-exact against textbook implementations (Hull, Wilmott, Lopez de Prado), tested across 120 accuracy benchmarks, and returns the same value for the same inputs every time. The agent can cite a specific tool call as the source for any number it presents.
+
+## Repository
+
+Source: [github.com/QuantOracledev/quantoracle](https://github.com/QuantOracledev/quantoracle)
+API: [api.quantoracle.dev](https://api.quantoracle.dev)
+Calculators: [quantoracle.dev](https://quantoracle.dev)
+OpenAPI spec: [api.quantoracle.dev/openapi.json](https://api.quantoracle.dev/openapi.json)
+
+## License
+
+MIT — same as the rest of QuantOracle.

package/dist/index.cjs

@@ -0,0 +1,453 @@
+'use strict';
+
+var zod = require('zod');
+var agentkit = require('@coinbase/agentkit');
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var PriceOptionSchema = zod.z.object({
+  S: zod.z.number().positive().describe("Spot price of the underlying"),
+  K: zod.z.number().positive().describe("Strike price"),
+  T: zod.z.number().positive().describe("Time to expiry in years (0.083 = 30 days)"),
+  r: zod.z.number().describe("Risk-free interest rate as decimal (0.05 = 5%)"),
+  sigma: zod.z.number().positive().describe("Annualized volatility as decimal (0.28 = 28%)"),
+  option_type: zod.z.enum([
+    "call",
+    "put"
+  ]).default("call").describe("Option type \u2014 call or put")
+}).describe("Black-Scholes option pricing with full Greeks. Returns price, breakeven, probability ITM, and all first-order Greeks (delta, gamma, vega, theta, rho).");
+var CalculateKellySchema = zod.z.object({
+  win_rate: zod.z.number().min(0.01).max(0.99).describe("Probability of winning (0-1)"),
+  avg_win: zod.z.number().positive().describe("Average dollar amount won on winning trades"),
+  avg_loss: zod.z.number().positive().describe("Average dollar amount lost on losing trades (positive number)")
+}).describe("Kelly Criterion optimal bet sizing. Returns full-, half-, and quarter-Kelly fractions plus edge and payoff ratio. Use half- or quarter-Kelly in real trading because edge estimates are noisy.");
+var SimulatePortfolioSchema = zod.z.object({
+  initial_value: zod.z.number().positive().describe("Starting portfolio value"),
+  annual_return: zod.z.number().describe("Expected annual return as decimal (0.08 = 8%)"),
+  annual_vol: zod.z.number().positive().describe("Annual volatility as decimal (0.18 = 18%)"),
+  years: zod.z.number().positive().max(30).describe("Time horizon in years (max 30)"),
+  simulations: zod.z.number().int().min(100).max(2500).default(1e3).describe("Number of Monte Carlo paths (100-2500; 1000 default)"),
+  contributions: zod.z.number().min(0).default(0).describe("Annual contribution amount (set 0 if none)"),
+  withdrawal_rate: zod.z.number().min(0).max(0.5).default(0).describe("Annual withdrawal rate as decimal (0.04 = 4%)")
+}).describe("Monte Carlo portfolio simulation. Returns distribution of terminal outcomes (P5/P25/median/P75/P95), probability of loss, probability of doubling, and probability of ruin under withdrawals.");
+var AssessPortfolioRiskSchema = zod.z.object({
+  returns: zod.z.array(zod.z.number()).min(30).max(5e3).describe("Array of historical periodic returns as decimals (0.012 = 1.2%). Daily returns assumed; 30-5000 observations."),
+  risk_free_rate: zod.z.number().default(0.04).describe("Annual risk-free rate as decimal (0.04 = 4%)"),
+  annualization_factor: zod.z.number().int().default(252).describe("252 for daily returns, 52 for weekly, 12 for monthly")
+}).describe("Composite full risk analysis: Sharpe, Sortino, Calmar, max drawdown, VaR, CVaR, Hurst exponent, and Kelly. PAID endpoint ($0.04 per call, settled in USDC). AgentKit's wallet pays automatically.");
+var RecommendHedgeSchema = zod.z.object({
+  position_type: zod.z.enum([
+    "long_stock",
+    "short_stock",
+    "long_crypto",
+    "long_options"
+  ]).describe("Type of position to hedge"),
+  position_value: zod.z.number().positive().describe("Current dollar value of the position"),
+  asset_price: zod.z.number().positive().describe("Current spot price of the underlying"),
+  volatility: zod.z.number().positive().describe("Annualized volatility of the underlying as decimal (0.28 = 28%)"),
+  time_horizon_days: zod.z.number().int().positive().default(30).describe("Hedge time horizon in days"),
+  max_hedge_cost_pct: zod.z.number().min(0).max(0.5).default(0.05).describe("Maximum hedge cost as fraction of position (0.05 = 5%)"),
+  r: zod.z.number().default(0.05).describe("Risk-free rate as decimal")
+}).describe("Recommend ranked hedge structures (collar, protective put, partial put, inverse) for an existing position. Returns each structure's cost, downside protection, and upside cap. PAID endpoint ($0.04 per call, settled in USDC). AgentKit's wallet pays automatically.");
+
+// constants.ts
+var QUANTORACLE_BASE_URL = process.env.QUANTORACLE_API_URL ?? "https://api.quantoracle.dev";
+var FREE_TIER_DAILY_LIMIT = 1e3;
+var USER_AGENT = "QuantOracle-AgentKit/1.0";
+
+// quantoracleActionProvider.ts
+function _ts_decorate(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate, "_ts_decorate");
+function _ts_metadata(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+__name(_ts_metadata, "_ts_metadata");
+var QuantOracleActionProvider = class extends agentkit.ActionProvider {
+  static {
+    __name(this, "QuantOracleActionProvider");
+  }
+  /**
+  * Constructor for QuantOracleActionProvider. No configuration required —
+  * the free tier covers the calculator endpoints, and paid composites use
+  * AgentKit's wallet to settle x402 payments.
+  */
+  constructor() {
+    super("quantoracle", []);
+  }
+  /**
+  * QuantOracle works on any network because the calculations are pure math
+  * (no on-chain reads). x402 settlements for paid endpoints work on Base
+  * mainnet and Solana mainnet, but the agent doesn't need to be on those
+  * networks to call the free-tier calculators.
+  *
+  * @returns true for any network
+  */
+  supportsNetwork = /* @__PURE__ */ __name((_network) => true, "supportsNetwork");
+  /**
+  * Price a European call or put option using Black-Scholes. Returns the
+  * theoretical fair value plus the full Greek profile (delta, gamma, vega,
+  * theta, rho). Use this before placing options orders to verify market
+  * prices are reasonable, or to compute expected option PnL given a view
+  * on the underlying.
+  *
+  * @param args - Spot price, strike, time to expiry, rate, vol, type
+  * @returns Markdown-formatted summary with price, breakeven, and Greeks
+  */
+  async priceOption(args) {
+    try {
+      const data = await this.callApi("/v1/options/price", args);
+      const ms = data.ms ?? 0;
+      const greeks = data.greeks ?? {};
+      return [
+        `**${args.option_type.toUpperCase()} on $${args.S} underlying, $${args.K} strike, ${(args.T * 365).toFixed(0)}d to expiry, ${(args.sigma * 100).toFixed(1)}% IV**`,
+        ``,
+        `- Price: $${data.price.toFixed(4)}`,
+        `- Breakeven: $${data.breakeven.toFixed(2)}`,
+        `- Probability ITM: ${(data.prob_itm * 100).toFixed(1)}%`,
+        `- Delta: ${greeks.delta.toFixed(4)}`,
+        `- Gamma: ${greeks.gamma.toFixed(4)}`,
+        `- Vega: ${greeks.vega.toFixed(4)}`,
+        `- Theta (per day): ${greeks.theta.toFixed(4)}`,
+        `- Rho: ${greeks.rho.toFixed(4)}`,
+        ``,
+        `_Computed in ${ms.toFixed(0)}ms via QuantOracle._`
+      ].join("\n");
+    } catch (err) {
+      return `Failed to price option: ${err instanceof Error ? err.message : String(err)}`;
+    }
+  }
+  /**
+  * Calculate Kelly Criterion optimal bet/position sizing. Returns full-,
+  * half-, and quarter-Kelly fractions. Use this to derive a defensible
+  * risk-per-trade fraction from your strategy's win rate and average
+  * win/loss profile, BEFORE sizing the position.
+  *
+  * @param args - Win rate, average win, average loss
+  * @returns Markdown-formatted summary with Kelly variants and edge analysis
+  */
+  async calculateKelly(args) {
+    try {
+      const data = await this.callApi("/v1/risk/kelly", {
+        mode: "discrete",
+        ...args
+      });
+      const fullKelly = data.full_kelly * 100;
+      const halfKelly = data.half_kelly * 100;
+      const quarterKelly = data.quarter_kelly * 100;
+      const recommendation = data.recommended.replace(/_/g, " ").toLowerCase();
+      return [
+        `**Kelly sizing for ${(args.win_rate * 100).toFixed(1)}% win rate, $${args.avg_win} avg win, $${args.avg_loss} avg loss**`,
+        ``,
+        `- Full Kelly: ${fullKelly.toFixed(2)}%`,
+        `- Half Kelly: ${halfKelly.toFixed(2)}% _(typical for risk-tolerant)_`,
+        `- Quarter Kelly: ${quarterKelly.toFixed(2)}% _(safer; recommended)_`,
+        `- Edge: ${data.edge.toFixed(2)}%`,
+        `- Payoff ratio: ${data.payoff_ratio.toFixed(2)}\xD7`,
+        `- **Recommendation:** ${recommendation}`,
+        ``,
+        fullKelly < 0 ? `_Negative edge \u2014 this strategy has negative expected value. Do not deploy capital._` : `_Computed via QuantOracle._`
+      ].join("\n");
+    } catch (err) {
+      return `Failed to calculate Kelly: ${err instanceof Error ? err.message : String(err)}`;
+    }
+  }
+  /**
+  * Run a Monte Carlo portfolio simulation to project the distribution of
+  * terminal outcomes. Use this to assess sequence-of-returns risk before
+  * deploying a strategy or to validate retirement-withdrawal sustainability.
+  *
+  * @param args - Initial value, return/vol assumptions, time horizon, contributions/withdrawals
+  * @returns Markdown-formatted summary with distribution percentiles and probability events
+  */
+  async simulatePortfolio(args) {
+    try {
+      const data = await this.callApi("/v1/simulate/montecarlo", args);
+      const t = data.terminal;
+      const probLoss = (data.prob_loss * 100).toFixed(1);
+      const probRuin = (data.prob_ruin * 100).toFixed(2);
+      const cagr = (data.cagr * 100).toFixed(2);
+      const fmt = /* @__PURE__ */ __name((v) => `$${v.toLocaleString(void 0, {
+        maximumFractionDigits: 0
+      })}`, "fmt");
+      return [
+        `**Monte Carlo: $${args.initial_value.toLocaleString()} over ${args.years} years, ${(args.annual_return * 100).toFixed(1)}% return, ${(args.annual_vol * 100).toFixed(1)}% vol**`,
+        ``,
+        `_Distribution of terminal outcomes (across ${args.simulations.toLocaleString()} simulated paths):_`,
+        `- Median: ${fmt(t.median)}`,
+        `- 5th percentile (worst 5%): ${fmt(t.p5)}`,
+        `- 95th percentile (best 5%): ${fmt(t.p95)}`,
+        `- Median CAGR: ${cagr}%`,
+        ``,
+        `**Probability events:**`,
+        `- Loss vs starting value: ${probLoss}%`,
+        `- Probability of ruin (portfolio depleted): ${probRuin}%`,
+        ``,
+        `_Computed in ${data.ms.toFixed(0)}ms via QuantOracle._`
+      ].join("\n");
+    } catch (err) {
+      return `Failed to simulate: ${err instanceof Error ? err.message : String(err)}`;
+    }
+  }
+  /**
+  * Compute a full risk-adjusted-return audit: Sharpe, Sortino, Calmar, max
+  * drawdown, VaR, CVaR, Kelly. PAID composite endpoint ($0.04 per call,
+  * settled in USDC via x402 — AgentKit's wallet handles payment automatically
+  * when the free tier is exceeded).
+  *
+  * @param args - Historical returns array, risk-free rate, annualization factor
+  * @returns Markdown-formatted comprehensive risk summary
+  */
+  async assessPortfolioRisk(args) {
+    try {
+      const data = await this.callApi("/v1/risk/full-analysis", args);
+      const sharpe = data.sharpe?.sharpe_ratio ?? 0;
+      const sortino = data.sortino?.sortino_ratio ?? 0;
+      const calmar = data.calmar?.calmar_ratio ?? 0;
+      const maxDd = data.drawdown?.max_drawdown ?? 0;
+      const varBlock = data.var;
+      const var95 = varBlock?.var_results?.["95"]?.var_pct ?? 0;
+      const cvar95 = varBlock?.var_results?.["95"]?.cvar_pct ?? 0;
+      const kelly = data.kelly?.kelly_fraction ?? 0;
+      const hurst = data.hurst?.hurst_exponent ?? 0;
+      return [
+        `**Risk audit on ${args.returns.length} observations** _(paid via x402, $0.04 USDC)_`,
+        ``,
+        `**Risk-adjusted return:**`,
+        `- Sharpe ratio: ${sharpe.toFixed(2)}`,
+        `- Sortino ratio: ${sortino.toFixed(2)}`,
+        `- Calmar ratio: ${calmar.toFixed(2)}`,
+        ``,
+        `**Tail risk:**`,
+        `- Max drawdown: ${(maxDd * 100).toFixed(2)}%`,
+        `- VaR (95%): ${var95.toFixed(2)}%`,
+        `- CVaR / Expected Shortfall (95%): ${cvar95.toFixed(2)}%`,
+        ``,
+        `**Sizing & regime:**`,
+        `- Kelly fraction: ${(kelly * 100).toFixed(2)}%`,
+        `- Hurst exponent: ${hurst.toFixed(3)} ${hurst > 0.6 ? "_(trending)_" : hurst < 0.4 ? "_(mean-reverting)_" : "_(random walk)_"}`,
+        ``,
+        `_Composite analysis via QuantOracle. Settled on-chain via x402._`
+      ].join("\n");
+    } catch (err) {
+      return `Failed to assess risk: ${err instanceof Error ? err.message : String(err)}`;
+    }
+  }
+  /**
+  * Recommend ranked hedge structures for an existing position. PAID
+  * composite endpoint ($0.04 per call, settled in USDC via x402).
+  *
+  * @param args - Position details and hedge parameters
+  * @returns Markdown-formatted ranked list of hedge structures
+  */
+  async recommendHedge(args) {
+    try {
+      const data = await this.callApi("/v1/hedging/recommend", args);
+      const structures = data.structures ?? [];
+      const lines = [
+        `**Hedge recommendations for $${args.position_value.toLocaleString()} ${args.position_type} position over ${args.time_horizon_days} days** _(paid via x402, $0.04 USDC)_`,
+        ``
+      ];
+      for (let i = 0; i < structures.length; i++) {
+        const s = structures[i];
+        lines.push(`**${i + 1}. ${s.name}** \u2014 cost ${(s.cost_pct * 100).toFixed(2)}% ($${s.cost_dollars.toFixed(2)}), floor ${(s.downside_floor * 100).toFixed(1)}%${s.upside_cap ? `, upside cap ${(s.upside_cap * 100).toFixed(1)}%` : ", unlimited upside"}`);
+        if (s.legs) {
+          for (const leg of s.legs) {
+            lines.push(`   - ${leg.action} ${leg.quantity}\xD7 ${leg.type} @ $${leg.strike.toFixed(2)} (premium $${leg.premium.toFixed(2)})`);
+          }
+        }
+        lines.push(``);
+      }
+      return lines.join("\n");
+    } catch (err) {
+      return `Failed to recommend hedge: ${err instanceof Error ? err.message : String(err)}`;
+    }
+  }
+  /**
+  * Internal helper. Posts JSON to a QuantOracle endpoint and returns the
+  * parsed response. Throws on non-2xx responses, including 402 Payment
+  * Required when the free tier is exceeded — at which point AgentKit's
+  * wallet should auto-retry with x402 payment headers (depending on your
+  * walletProvider setup).
+  *
+  * @param path - Endpoint path beginning with /v1/...
+  * @param body - JSON-serializable request body
+  * @returns Parsed JSON response
+  */
+  async callApi(path, body) {
+    const res = await fetch(`${QUANTORACLE_BASE_URL}${path}`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "User-Agent": USER_AGENT,
+        "X-Source": "agentkit"
+      },
+      body: JSON.stringify(body)
+    });
+    if (!res.ok) {
+      let detail = "";
+      try {
+        const j = await res.json();
+        detail = JSON.stringify(j).slice(0, 200);
+      } catch {
+      }
+      throw new Error(`QuantOracle ${path} returned ${res.status}: ${detail}`);
+    }
+    return await res.json();
+  }
+};
+_ts_decorate([
+  agentkit.CreateAction({
+    name: "price_option",
+    description: `
+Price a European call or put option using Black-Scholes with full Greeks.
+Returns the option's theoretical price, breakeven, probability ITM, and
+all first-order Greeks (delta, gamma, vega, theta, rho).
+
+Use this when:
+- Verifying that a market option price is reasonable before placing an order
+- Estimating PnL on an existing options position given a view on the underlying
+- Computing position deltas for portfolio hedging decisions
+- Sizing options trades based on Greek exposures
+
+Inputs: spot price, strike, time to expiry (in years; 30 days = 0.083),
+risk-free rate, volatility, option type (call or put).
+`,
+    schema: PriceOptionSchema
+  }),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof zod.z === "undefined" || typeof zod.z.infer === "undefined" ? Object : zod.z.infer
+  ]),
+  _ts_metadata("design:returntype", Promise)
+], QuantOracleActionProvider.prototype, "priceOption", null);
+_ts_decorate([
+  agentkit.CreateAction({
+    name: "calculate_kelly",
+    description: `
+Calculate Kelly Criterion optimal bet sizing given a strategy's win rate
+and average win/loss amounts. Returns the full-, half-, and quarter-Kelly
+fractions, the edge per dollar risked, and the payoff ratio.
+
+Use this when:
+- Deriving the risk-per-trade fraction for a position-sizing system
+- Comparing two strategies head-to-head (higher Kelly = better edge per unit risk)
+- Validating that a strategy is positive-expected-value before deploying capital
+
+The formula assumes binary outcomes with fixed amounts (suits options trades,
+event-driven bets, or any discrete win/loss strategy). For continuous-return
+strategies, see the QuantOracle API endpoint /v1/risk/kelly with mode=continuous.
+
+Most professionals use half- or quarter-Kelly because edge estimates are noisy
+and overestimating edge causes severe overbetting.
+`,
+    schema: CalculateKellySchema
+  }),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof zod.z === "undefined" || typeof zod.z.infer === "undefined" ? Object : zod.z.infer
+  ]),
+  _ts_metadata("design:returntype", Promise)
+], QuantOracleActionProvider.prototype, "calculateKelly", null);
+_ts_decorate([
+  agentkit.CreateAction({
+    name: "simulate_portfolio",
+    description: `
+Run a Monte Carlo simulation projecting the distribution of portfolio
+outcomes over a chosen time horizon. Returns terminal-value percentiles
+(P5/P25/median/P75/P95), probability of loss, probability of doubling,
+and probability of ruin under withdrawals.
+
+Use this when:
+- Stress-testing a withdrawal-rate plan (e.g. "is 4% sustainable for 30 years?")
+- Comparing portfolio strategies head-to-head
+- Quantifying sequence-of-returns risk for retirement-style allocations
+- Showing a user the realistic range of outcomes (not just expected return)
+
+The simulation uses geometric Brownian motion (log-normal returns) \u2014 a
+standard textbook assumption that is reasonable for diversified portfolios
+but underestimates fat-tail risk for high-vol single-asset strategies.
+`,
+    schema: SimulatePortfolioSchema
+  }),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof zod.z === "undefined" || typeof zod.z.infer === "undefined" ? Object : zod.z.infer
+  ]),
+  _ts_metadata("design:returntype", Promise)
+], QuantOracleActionProvider.prototype, "simulatePortfolio", null);
+_ts_decorate([
+  agentkit.CreateAction({
+    name: "assess_portfolio_risk",
+    description: `
+Run a comprehensive risk audit on a return series. Returns Sharpe ratio,
+Sortino ratio, Calmar ratio, max drawdown, VaR (95%/99%), CVaR (Expected
+Shortfall), Kelly fraction, and Hurst exponent (regime indicator).
+
+Use this when:
+- Evaluating a backtest before deploying real capital
+- Auditing an existing strategy's risk-adjusted performance
+- Comparing two strategies on multiple risk dimensions in one call
+- Generating a one-page risk summary for a stakeholder
+
+PAID composite endpoint: $0.04 per call, settled in USDC via x402 on Base
+or Solana. AgentKit's wallet pays automatically \u2014 no API key, no signup.
+The savings vs running 8 separate calculator calls is meaningful both in
+cost and in latency.
+
+Requires at least 30 observations of historical returns; 252+ recommended
+for statistical significance.
+`,
+    schema: AssessPortfolioRiskSchema
+  }),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof zod.z === "undefined" || typeof zod.z.infer === "undefined" ? Object : zod.z.infer
+  ]),
+  _ts_metadata("design:returntype", Promise)
+], QuantOracleActionProvider.prototype, "assessPortfolioRisk", null);
+_ts_decorate([
+  agentkit.CreateAction({
+    name: "recommend_hedge",
+    description: `
+Recommend ranked hedge structures (collar, protective put, partial put,
+inverse) for an existing position. Each recommendation includes the cost
+as a percentage of position value, the downside protection floor, and the
+upside cap (if any).
+
+Use this when:
+- An agent holding a long position wants to limit downside before an event
+  (earnings, FOMC, FDA decision) without selling
+- An agent needs to compare hedge strategies head-to-head by cost vs protection
+- Programmatic risk management of crypto positions ahead of high-vol periods
+
+PAID composite endpoint: $0.04 per call, settled in USDC via x402 on Base or
+Solana. AgentKit's wallet pays automatically. The output is a ranked table
+the agent can present to a user or use directly to place hedge orders.
+`,
+    schema: RecommendHedgeSchema
+  }),
+  _ts_metadata("design:type", Function),
+  _ts_metadata("design:paramtypes", [
+    typeof zod.z === "undefined" || typeof zod.z.infer === "undefined" ? Object : zod.z.infer
+  ]),
+  _ts_metadata("design:returntype", Promise)
+], QuantOracleActionProvider.prototype, "recommendHedge", null);
+var quantoracleActionProvider = /* @__PURE__ */ __name(() => new QuantOracleActionProvider(), "quantoracleActionProvider");
+
+exports.AssessPortfolioRiskSchema = AssessPortfolioRiskSchema;
+exports.CalculateKellySchema = CalculateKellySchema;
+exports.FREE_TIER_DAILY_LIMIT = FREE_TIER_DAILY_LIMIT;
+exports.PriceOptionSchema = PriceOptionSchema;
+exports.QUANTORACLE_BASE_URL = QUANTORACLE_BASE_URL;
+exports.QuantOracleActionProvider = QuantOracleActionProvider;
+exports.RecommendHedgeSchema = RecommendHedgeSchema;
+exports.SimulatePortfolioSchema = SimulatePortfolioSchema;
+exports.USER_AGENT = USER_AGENT;
+exports.quantoracleActionProvider = quantoracleActionProvider;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map