otto-intel-mcp 0.1.2 → 0.1.4

package/dist/stock-buy-definition.js

@@ -0,0 +1,127 @@
+/**
+ * `otto_prepare_stock_buy` — a tokenized-stock BUY (Coinbase B20 on Base) as a thin constructor over
+ * `otto_prepare_swap` (Founder word: delegation beyond swaps, 2026-09-03).
+ *
+ * WHY IT IS A SWAP, PROVEN LIVE (li.quest, 2026-09-03, production params `integrator=ottowallet&fee=0.001`):
+ * $10 USDC → AAPLc quoted as a same-chain route whose transactionRequest targets the reviewed LI.FI
+ * diamond with selector 0x5fd9ae2e = `swapTokensMultipleV3ERC20ToERC20` — one of the two fenced
+ * GenericSwapV3 entry points — USDC is the v1 allow-listed input token, and the receiver is the signing
+ * account. A B20 buy is therefore INSIDE the delegation fence as it stands (v1/v2, unchanged); the SELL
+ * direction needs a B20-token approve to the diamond, which fence v2 grants only to the two vault share
+ * tokens — a sell is fence v3, sized in docs/0903_delegation_empire_scope.md, not shipped here.
+ *
+ * WHAT THIS TOOL PINS THAT A RAW SWAP DOES NOT:
+ *   - the OUTPUT token is the registry row's B20 contract, never a caller input;
+ *   - the row is the CURRENT registry record (caller's commitment must match the recomputed one);
+ *   - chain 8453 / venue COINBASE_B20 / asset USDC, from the row, refused otherwise;
+ *   - PRICE PARITY on the WORST PERMISSIBLE FILL: `amount / minTokens` (the floor the router
+ *     enforces) may not exceed the row's own Chainlink total-return mark by more than the pinned
+ *     tolerance, and the slippage band is capped — a thin or poisoned pool, or a wide floor, can
+ *     never execute a delegated buy far over the venue's own mark;
+ *   - ORACLE FRESHNESS: a frozen feed (> 24 h — the dashboard's own frozen threshold; feeds hold their
+ *     last value off-hours) cannot anchor parity, so the buy is refused by name. Off-hours the pool may
+ *     legitimately trade away from Friday's close; a delegated buy waits for a live reference.
+ * The generic `otto_prepare_swap` refuses every executable-equity token address in either direction
+ * (the same discipline as the yield share tokens): this constructor is the only delegated path.
+ */
+import { z } from 'zod';
+import { ACCOUNT_PROFILE_SCHEMA, EXECUTION_ENVELOPE_SCHEMA, PREPARE_SWAP_INPUT_SCHEMA, } from './execution-tool-definitions.js';
+export const STOCK_BUY_TOOL_NAME = 'otto_prepare_stock_buy';
+/**
+ * 🔴 PINNED PRICE-PARITY TOLERANCE, in basis points of the Chainlink mark, on the WORST PERMISSIBLE
+ * FILL (`fromAmount / minTokens` — the floor the router actually enforces on-chain, fees included).
+ *
+ * Gate G1: a guard on the QUOTE alone lets the permitted slippage carry the executed fill past the
+ * tolerance (quote at 0 bps + 1,000-bps floor = an 11% overpay the guard never saw). So parity is
+ * checked against the FLOOR, and the floor's own room is bounded: this constructor caps
+ * `slippage.maxBps` at 100 (the generic swap's 1..1000 range is not a stock buy's).
+ *
+ * Derivation (live li.quest quotes 2026-09-03/04, production params):
+ *   - LI.FI fixed integrator fee 0.25% of the input                                    → 25 bps
+ *   - observed B20 pool spread over the oracle mark (~21 bps AAPLc · ~34 bps NVDAc
+ *     at small size; thin pools move with size)                                        → ~50 bps p95
+ *   - the slippage floor this schema permits                                           → ≤ 100 bps
+ *   = 175 bps on the worst permissible fill: whatever routing and slippage do, a delegated buy can
+ *   never execute more than 1.75% over the venue's own mark. A test pins this value; widening it
+ *   must redden that test.
+ */
+export const STOCK_BUY_PARITY_TOLERANCE_BPS = 175;
+/** Gate G1: the tightest slippage band of any constructor — the tolerance above assumes it. */
+export const STOCK_BUY_MAX_SLIPPAGE_BPS = 100;
+/** The dashboard's frozen threshold (freshness.ts STALE_MAX_MIN): beyond this the feed cannot anchor parity. */
+export const STOCK_BUY_MAX_ORACLE_AGE_SEC = 24 * 60 * 60;
+const uintString = z
+    .string()
+    .regex(/^[1-9]\d*$/, 'must be a positive decimal integer')
+    .refine((value) => BigInt(value) <= (1n << 256n) - 1n, 'must fit uint256');
+export const PREPARE_STOCK_BUY_INPUT_SCHEMA = z
+    .object({
+    accountProfile: ACCOUNT_PROFILE_SCHEMA,
+    executableEquityId: z
+        .string()
+        .min(1)
+        .max(120)
+        .describe('The executable equity id the READ half served, e.g. b20-nvda (Coinbase B20 on Base only).'),
+    registryCommitment: z
+        .string()
+        .regex(/^sha256:[0-9a-f]{64}$/, 'must be the sha256:… registry commitment the READ half served')
+        .describe("The registry commitment served with that row. It must equal the commitment this server recomputes over the CURRENT record; a stale or foreign row is refused by name."),
+    amount: uintString.describe('Exact USDC amount to spend, in atomic units (6 decimals).'),
+    slippage: z
+        .object({
+        maxBps: z.number().int().min(1).max(STOCK_BUY_MAX_SLIPPAGE_BPS),
+    })
+        .strict(),
+    client_ref: z.string().trim().min(1).max(128).optional(),
+})
+    .strict();
+const addressOut = z.string().regex(/^0x[0-9a-fA-F]{40}$/);
+const uintOut = z.string().regex(/^\d+$/);
+export const STOCK_BUY_PREVIEW_SCHEMA = z
+    .object({
+    equity_id: z.string(),
+    venue: z.literal('COINBASE_B20'),
+    chain_id: z.literal(8453),
+    underlying: z.string(),
+    symbol: z.string(),
+    token: addressOut,
+    asset: addressOut,
+    /** The USDC spent (atomic) — the cap's gross at submit is this same approve amount. */
+    amount: uintOut,
+    /** Tokens the route quotes for `amount` (8-decimal B20 units). */
+    expected_tokens: uintOut,
+    /** The on-chain floor the router enforces; what `prepareInput.slippage.minAmountOut` carries. */
+    min_tokens: uintOut,
+    /** The Chainlink total-return mark at prepare time (8 decimals) and its age. */
+    oracle_price: uintOut,
+    oracle_age_sec: z.number().int().min(0),
+    /** Premium of the WORST PERMISSIBLE FILL (amount / min_tokens) over the mark, in bps (gate G1). */
+    parity_premium_bps: z.number().int().min(0),
+    parity_tolerance_bps: z.literal(STOCK_BUY_PARITY_TOLERANCE_BPS),
+    /** The fee lines the router attached to the quote, as LI.FI names them (amount in USD). */
+    quoted_fees: z.array(z.object({ name: z.string(), amount_usd: z.string() }).strict()),
+    /** The route's own gas estimate for the call step, in USD, when LI.FI reported one. */
+    quoted_gas_usd: z.string().optional(),
+})
+    .strict();
+export const PREPARE_STOCK_BUY_OUTPUT_SCHEMA = z
+    .object({
+    /** The EXACT `otto_prepare_swap` envelope — submit it unchanged. */
+    envelope: EXECUTION_ENVELOPE_SCHEMA,
+    /**
+     * The EXACT `otto_prepare_swap` request that produced the envelope, with `slippage.minAmountOut`
+     * FILLED from the quote's floor — the pair `otto_submit_under_delegation` takes, verbatim.
+     */
+    prepareInput: PREPARE_SWAP_INPUT_SCHEMA,
+    preview: STOCK_BUY_PREVIEW_SCHEMA,
+    registry_commitment: z.string().regex(/^sha256:[0-9a-f]{64}$/),
+})
+    .strict();
+export const STOCK_BUY_TOOL_DEFINITION = Object.freeze({
+    name: STOCK_BUY_TOOL_NAME,
+    title: 'Prepare a tokenized-stock buy (Coinbase B20 on Base) as a delegable swap pair',
+    description: "Prepare the EXACT otto_prepare_swap pair (envelope + prepareInput) that buys one of the executable Coinbase B20 tokenized equities on Base with USDC, as a LI.FI route through the fenced diamond whose receiver is the signing account. The token comes from the registry row named by executableEquityId and is never an input; the caller's registryCommitment must equal the commitment recomputed over the current record. The WORST PERMISSIBLE FILL (amount over the route's own floor) is checked against the equity's own Chainlink total-return mark and refused when it exceeds the pinned tolerance, or when the feed is frozen (> 24 h). Returns the pair unchanged plus a preview; never signs or submits — submit the pair through otto_submit_under_delegation under the end user's per-swap cap.",
+    inputSchema: PREPARE_STOCK_BUY_INPUT_SCHEMA,
+    outputSchema: PREPARE_STOCK_BUY_OUTPUT_SCHEMA,
+});
+//# sourceMappingURL=stock-buy-definition.js.map

package/dist/stock-buy-oracle.d.ts

@@ -0,0 +1,8 @@
+/**
+ * The viem-backed `EquityOracleReader` — one `latestRoundData` read per prepare, over the same Base
+ * public client the delegated signer uses. In its own module (not stock-buy.ts) so execution-tools.ts
+ * can import it without a cycle, mirroring viemYieldVaultReader's placement.
+ */
+import { type PublicClient } from 'viem';
+import type { EquityOracleReader } from './stock-buy-definition.js';
+export declare function viemEquityOracleReader(pub: PublicClient): EquityOracleReader;

package/dist/stock-buy-oracle.js

@@ -0,0 +1,22 @@
+/**
+ * The viem-backed `EquityOracleReader` — one `latestRoundData` read per prepare, over the same Base
+ * public client the delegated signer uses. In its own module (not stock-buy.ts) so execution-tools.ts
+ * can import it without a cycle, mirroring viemYieldVaultReader's placement.
+ */
+import { parseAbi } from 'viem';
+const AGGREGATOR_ABI = parseAbi([
+    'function latestRoundData() view returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound)',
+]);
+export function viemEquityOracleReader(pub) {
+    return Object.freeze({
+        async latestRoundData(feed) {
+            const [, answer, , updatedAt] = await pub.readContract({
+                address: feed,
+                abi: AGGREGATOR_ABI,
+                functionName: 'latestRoundData',
+            });
+            return { answer, updatedAt };
+        },
+    });
+}
+//# sourceMappingURL=stock-buy-oracle.js.map

package/dist/stock-buy.d.ts

@@ -0,0 +1,17 @@
+import { type ExecutableEquity } from './executable-equities.js';
+import { type ExecutionToolRuntime } from './execution-tools.js';
+import { type PrepareStockBuyInput, type PrepareStockBuyOutput } from './stock-buy-definition.js';
+/** Step 2: the registry row, pinned to the caller's commitment and to Base / B20 / USDC. */
+export declare function resolveExecutableEquity(input: Pick<PrepareStockBuyInput, 'executableEquityId' | 'registryCommitment'>): ExecutableEquity;
+/** Step 3, pure: the oracle answer is usable only when positive and within the frozen threshold. */
+export declare function assertOracleUsable(answer: bigint, updatedAtSec: bigint, nowSec: number): number;
+/**
+ * Step 5, pure and EXACT by cross-multiplication: the premium of a fill of `tokens` for `amountUsdc`
+ * over the mark, in bps (0 when at or under the mark) — called with the route's FLOOR (gate G1).
+ * Units: amountUsdc 6dp · tokens 8dp (B20) · oracle 8dp.
+ *   implied = amountUsdc / tokens; refuse when implied > oracle × (1 + tol/10000):
+ *   amountUsdc × 10^8 × 10^8 × 10000  >  tokens × oracle × 10^6 × (10000 + tol)
+ * (both sides scaled to 6+8+8 decimal places plus the bps factor — no floats anywhere).
+ */
+export declare function assertPriceParity(amountUsdc: bigint, quotedTokens: bigint, oraclePrice: bigint): number;
+export declare function prepareStockBuy(runtime: ExecutionToolRuntime, rawInput: unknown, signal?: AbortSignal): Promise<PrepareStockBuyOutput>;

package/dist/stock-buy.js

@@ -0,0 +1,164 @@
+/**
+ * `otto_prepare_stock_buy` — the constructor. See `stock-buy-definition.ts` for WHY it is a swap
+ * and what it pins.
+ *
+ * Order of operations:
+ *   1. parse the strict input;
+ *   2. the registry row for `executableEquityId` (unknown → refused), the CURRENT commitment over the
+ *      complete record must equal the caller's, chain 8453 / venue COINBASE_B20 / asset USDC from the
+ *      row (anything else refused by name);
+ *   3. the row's Chainlink total-return mark (no reader / read failure / non-positive answer → refused;
+ *      feed older than the pinned frozen threshold → refused: parity has no live anchor);
+ *   4. ONE LI.FI quote through `quoteSwap` for `USDC → row.tokenAddress` from the signing account;
+ *   5. PRICE PARITY, exact by cross-multiplication in atomic units, on the WORST PERMISSIBLE FILL
+ *      (`amount / minTokens`, gate G1): the floor the router enforces may not exceed the mark by
+ *      more than the pinned tolerance;
+ *   6. the swap prepareInput with `slippage.minAmountOut` = the quote's floor, then the envelope from
+ *      THAT quote via `prepareSwapFromQuote` — the pair `otto_submit_under_delegation` takes verbatim.
+ *
+ * Nothing here signs, submits, or touches the delegation; the cap applies at submit, to the approve amount.
+ */
+import { getAddress } from 'viem';
+import { getExecutableEquity, getExecutableEquityCommitment, } from './executable-equities.js';
+import { refuse } from './execution-errors.js';
+import { PREPARE_SWAP_INPUT_SCHEMA } from './execution-tool-definitions.js';
+import { prepareSwapFromQuote, quoteSwap } from './execution-tools.js';
+import { PREPARE_STOCK_BUY_INPUT_SCHEMA, PREPARE_STOCK_BUY_OUTPUT_SCHEMA, STOCK_BUY_MAX_ORACLE_AGE_SEC, STOCK_BUY_PARITY_TOLERANCE_BPS, } from './stock-buy-definition.js';
+/** Step 2: the registry row, pinned to the caller's commitment and to Base / B20 / USDC. */
+export function resolveExecutableEquity(input) {
+    const equity = getExecutableEquity(input.executableEquityId);
+    if (!equity) {
+        return refuse('EQUITY_UNKNOWN', `${input.executableEquityId} is not an executable equity on this server`);
+    }
+    const current = getExecutableEquityCommitment(equity);
+    if (current !== input.registryCommitment) {
+        return refuse('EQUITY_REGISTRY_MISMATCH', `the registry commitment presented for ${equity.id} is not the current record's; re-read the equity and prepare again`);
+    }
+    if (equity.chainId !== 8453) {
+        return refuse('EQUITY_UNKNOWN', `${equity.id} is not on Base mainnet (8453)`);
+    }
+    if (equity.venue !== 'COINBASE_B20') {
+        return refuse('EQUITY_UNKNOWN', `${equity.id} is not a Coinbase B20 equity; only the B20 venue is executable`);
+    }
+    if (equity.asset.symbol !== 'USDC') {
+        return refuse('EQUITY_UNKNOWN', `${equity.id} does not buy with USDC`);
+    }
+    return equity;
+}
+/** Step 3, pure: the oracle answer is usable only when positive and within the frozen threshold. */
+export function assertOracleUsable(answer, updatedAtSec, nowSec) {
+    if (answer <= 0n) {
+        return refuse('EQUITY_ORACLE_UNAVAILABLE', 'the Chainlink mark reads non-positive; parity has no anchor');
+    }
+    const age = nowSec - Number(updatedAtSec);
+    if (age < 0)
+        return 0; // clock skew clamps to 0, same as the dashboard's feedAge
+    if (age > STOCK_BUY_MAX_ORACLE_AGE_SEC) {
+        return refuse('EQUITY_ORACLE_FROZEN', `the Chainlink mark is ${Math.floor(age / 3600)} h old (frozen past ${STOCK_BUY_MAX_ORACLE_AGE_SEC / 3600} h — the feed holds its last value off-hours); a delegated buy waits for a live reference`);
+    }
+    return age;
+}
+/**
+ * Step 5, pure and EXACT by cross-multiplication: the premium of a fill of `tokens` for `amountUsdc`
+ * over the mark, in bps (0 when at or under the mark) — called with the route's FLOOR (gate G1).
+ * Units: amountUsdc 6dp · tokens 8dp (B20) · oracle 8dp.
+ *   implied = amountUsdc / tokens; refuse when implied > oracle × (1 + tol/10000):
+ *   amountUsdc × 10^8 × 10^8 × 10000  >  tokens × oracle × 10^6 × (10000 + tol)
+ * (both sides scaled to 6+8+8 decimal places plus the bps factor — no floats anywhere).
+ */
+export function assertPriceParity(amountUsdc, quotedTokens, oraclePrice) {
+    if (quotedTokens <= 0n) {
+        return refuse('STOCK_BUY_PARITY', 'the route quotes zero tokens for this amount; the buy is not prepared');
+    }
+    const lhs = amountUsdc * 10n ** 16n * 10000n; // 6dp → ×10^16 to the 6+8+8 plane, × bps base
+    const rhsBase = quotedTokens * oraclePrice * 10n ** 6n; // 8dp × 8dp → ×10^6 to the same plane
+    if (lhs > rhsBase * BigInt(10_000 + STOCK_BUY_PARITY_TOLERANCE_BPS)) {
+        const premiumBps = Number((lhs - rhsBase * 10000n) / rhsBase);
+        return refuse('STOCK_BUY_PARITY', `the route's gross implied price is ${premiumBps} bps over the equity's own Chainlink mark (tolerance ${STOCK_BUY_PARITY_TOLERANCE_BPS} bps); the buy is not prepared`);
+    }
+    const premium = lhs > rhsBase * 10000n ? Number((lhs - rhsBase * 10000n) / rhsBase) : 0;
+    return premium;
+}
+/** The fee lines LI.FI attached, as it names them — read for the preview; nothing is derived from them. */
+function quotedFeeLines(quote) {
+    const estimate = quote.estimate;
+    const lines = Array.isArray(estimate.feeCosts) ? estimate.feeCosts : [];
+    return lines.flatMap((line) => {
+        const l = line;
+        return typeof l.name === 'string' && typeof l.amountUSD === 'string'
+            ? [{ name: l.name, amount_usd: l.amountUSD }]
+            : [];
+    });
+}
+function quotedGasUsd(quote) {
+    const estimate = quote.estimate;
+    const first = Array.isArray(estimate.gasCosts) ? estimate.gasCosts[0] : undefined;
+    return typeof first?.amountUSD === 'string' ? first.amountUSD : undefined;
+}
+export async function prepareStockBuy(runtime, rawInput, signal) {
+    const input = PREPARE_STOCK_BUY_INPUT_SCHEMA.parse(rawInput);
+    const equity = resolveExecutableEquity(input);
+    const reader = runtime.equityOracleReader;
+    if (!reader) {
+        return refuse('EQUITY_ORACLE_UNAVAILABLE', 'this server has no equity oracle reader, so price parity cannot be checked; nothing is prepared');
+    }
+    const token = getAddress(equity.tokenAddress);
+    const asset = getAddress(equity.asset.address);
+    const amount = BigInt(input.amount);
+    // 3. The mark, before any quote — a buy with no anchor is refused without touching LI.FI.
+    let round;
+    try {
+        round = await reader.latestRoundData(equity.feed);
+    }
+    catch {
+        return refuse('EQUITY_ORACLE_UNAVAILABLE', "the equity's Chainlink feed could not be read, so price parity cannot be checked; nothing is prepared");
+    }
+    // the runtime's clock, not the wall clock — freshness must be provable under a fixed now
+    const oracleAge = assertOracleUsable(round.answer, round.updatedAt, Math.floor(runtime.nowMs() / 1000));
+    // 4. The swap request, toToken PINNED to the registry token. Quoted once.
+    const quoteInput = PREPARE_SWAP_INPUT_SCHEMA.parse({
+        accountProfile: input.accountProfile,
+        chainId: equity.chainId,
+        fromToken: asset,
+        toToken: token,
+        fromAmount: input.amount,
+        slippage: { maxBps: input.slippage.maxBps },
+        ...(input.client_ref ? { client_ref: input.client_ref } : {}),
+    });
+    const quote = await quoteSwap(runtime, quoteInput, signal);
+    const expectedTokens = BigInt(quote.estimate.toAmount);
+    const minTokens = BigInt(quote.estimate.toAmountMin);
+    // 5. Parity against the venue's own mark, on the WORST PERMISSIBLE FILL (gate G1): the router
+    // enforces minTokens, not the quote — so the floor is what the tolerance must bound.
+    const premiumBps = assertPriceParity(amount, minTokens, round.answer);
+    // 6. The pair: the floor goes INTO prepareInput before the envelope is built, so the intent digest binds it.
+    const prepareInput = PREPARE_SWAP_INPUT_SCHEMA.parse({
+        ...quoteInput,
+        slippage: { maxBps: input.slippage.maxBps, minAmountOut: minTokens.toString() },
+    });
+    const envelope = prepareSwapFromQuote(runtime, prepareInput, quote);
+    return PREPARE_STOCK_BUY_OUTPUT_SCHEMA.parse({
+        envelope,
+        prepareInput,
+        preview: {
+            equity_id: equity.id,
+            venue: 'COINBASE_B20',
+            chain_id: 8453,
+            underlying: equity.underlying,
+            symbol: equity.symbol,
+            token,
+            asset,
+            amount: amount.toString(),
+            expected_tokens: expectedTokens.toString(),
+            min_tokens: minTokens.toString(),
+            oracle_price: round.answer.toString(),
+            oracle_age_sec: oracleAge,
+            parity_premium_bps: premiumBps,
+            parity_tolerance_bps: STOCK_BUY_PARITY_TOLERANCE_BPS,
+            quoted_fees: quotedFeeLines(quote),
+            ...(quotedGasUsd(quote) !== undefined ? { quoted_gas_usd: quotedGasUsd(quote) } : {}),
+        },
+        registry_commitment: input.registryCommitment,
+    });
+}
+//# sourceMappingURL=stock-buy.js.map

package/dist/tool-definitions.d.ts

@@ -10,11 +10,13 @@ export interface IntelToolDefinition {
     readonly inputSchema: z.ZodObject;
     readonly priceUsd: string;
     readonly maxPaymentAtomic: bigint;
+    /** No compatible warm-only backend: use the public paid rail without spending the free grant. */
+    readonly paidOnly?: boolean;
     readonly toQuery: (input: ToolArguments) => Record<string, string>;
 }
 /**
  * The single v1 catalog consumed by both the hosted and stdio transports.
- * Every entry is quote/data-only and backed by the data-endpoints service.
+ * Every entry is quote/data-only. Entries outside data-endpoints' warm-only backend are paid-only.
  */
 export declare const TOOL_DEFINITIONS: readonly IntelToolDefinition[];
 export declare const TOOL_DEFINITION_BY_NAME: Map<`otto_${string}`, IntelToolDefinition>;

package/dist/tool-definitions.js

@@ -33,6 +33,28 @@ const managerSchema = z
         .describe('SEC manager CIK, such as 1067983, or listed manager ticker, such as BLK.'),
 })
     .strict();
+/**
+ * Network-qualified stock identity for `/stock-pools`. VENDORED grammar: a Railway build reads one
+ * service dir, so this cannot import data-endpoints' `normalizeStockPoolsKey` — the source-side lock
+ * test (`services/data-endpoints/src/endpoints/stock-pools-mcp-lock.test.ts`) fails when the two
+ * drift. A BARE ticker is rejected on purpose: the same ticker is tokenized on several chains, and
+ * guessing one would answer a question the caller did not ask.
+ */
+const stockPoolsSchema = z
+    .object({
+    stock: z
+        .string()
+        .trim()
+        .min(3)
+        .max(64)
+        // Case-insensitive chain and an optional leading `$` — the SAME spellings the endpoint's
+        // normalizer accepts. Codex r1 seam: the two rails previously disagreed, so `$MU` and
+        // `ROBINHOOD:MU` were accepted on x402 and rejected here; the lock test now pins a shared
+        // accepted/rejected table rather than the regex's shape.
+        .regex(/^\$?(robinhood|base|bsc|solana):[A-Za-z0-9._-]{1,50}$/i, 'stock must be network-qualified, for example robinhood:MU')
+        .describe('Network-qualified tokenized-stock identity: "<network>:<TICKER>" or "<network>:<token address>", where network is robinhood, base, bsc or solana. Example: robinhood:MU. A bare ticker is rejected, and so is a ticker that names two deployments on one chain — give the token address for those.'),
+})
+    .strict();
 function noQuery() {
     return {};
 }
@@ -45,6 +67,9 @@ function managerQuery(input) {
 function thesisQuery(input) {
     return typeof input.thesis === 'string' ? { thesis: input.thesis } : {};
 }
+function stockPoolsQuery(input) {
+    return { stock: String(input.stock).replace(/^\$/, '') };
+}
 function usdcAtomic(priceUsd) {
     if (!/^\d+\.\d{1,6}$/.test(priceUsd)) {
         throw new Error(`invalid USDC price: ${priceUsd}`);
@@ -61,13 +86,32 @@ function defineTool(definition) {
 }
 /**
  * The single v1 catalog consumed by both the hosted and stdio transports.
- * Every entry is quote/data-only and backed by the data-endpoints service.
+ * Every entry is quote/data-only. Entries outside data-endpoints' warm-only backend are paid-only.
  */
 export const TOOL_DEFINITIONS = Object.freeze([
+    defineTool({
+        name: 'otto_crypto_news',
+        title: 'Otto crypto news',
+        description: 'Read importance-ranked crypto headlines with source links and publication times, plus a sentiment-scored market brief. The hourly snapshot reports its analysis window and freshness; missing source links remain unknown. Paid-only, including the first call: this tool preserves the hosted free intelligence allowance. Market context only; not a recommendation.',
+        endpointId: 'crypto-news',
+        inputSchema: noArgumentsSchema,
+        priceUsd: '0.001',
+        paidOnly: true,
+        toQuery: noQuery,
+    }),
+    defineTool({
+        name: 'otto_news_recaps',
+        title: 'Otto crypto market recap',
+        description: 'Read a concise crypto market recap with ranked stories, source links where available, analysis window and freshness. A cached result can use the hosted free allowance; a cold or unavailable read returns a payment challenge without generating a recap for free. Stale-but-servable cached results retain their upstream freshness and degraded indicators. Market context only; not a recommendation.',
+        endpointId: 'news-recaps',
+        inputSchema: noArgumentsSchema,
+        priceUsd: '0.003',
+        toQuery: noQuery,
+    }),
     defineTool({
         name: 'otto_tokenized_equities',
         title: 'Otto tokenized equities',
-        description: 'Scan the live registry of US equities and ETFs tokenized on Robinhood Chain (4663): symbol, canonical token address, decimals, reference price, and verifiable tradability signal. An optional thesis returns a relevance-ranked shortlist with a match reason per row. Data only; not a recommendation or executable quote.',
+        description: 'Scan the live registry of US equities and ETFs tokenized on Robinhood Chain (4663): symbol, canonical token address, decimals, the executable buy price a live route returns, the catalog reference price and the deviation between them, plus a verifiable tradability signal. An optional thesis returns a relevance-ranked shortlist with a match reason per row. Data only; not a recommendation or executable quote.',
         endpointId: 'tokenized-equities',
         inputSchema: thesisSchema,
         priceUsd: '0.001',
@@ -157,6 +201,15 @@ export const TOOL_DEFINITIONS = Object.freeze([
         priceUsd: '0.001',
         toQuery: noQuery,
     }),
+    defineTool({
+        name: 'otto_stock_pools',
+        title: 'Otto tokenized-stock pool discovery',
+        description: 'Find the DEX pools a tokenized US stock or ETF is actually a member of, on Robinhood Chain, Base, BNB Chain or Solana. Returns each pool id (Uniswap v4 pool ids kept distinct from v3 pool addresses), DEX and version, which side the asset is on, the counterpart token with an evidence-backed classification (verified stock, verified stablecoin, or unclassified), reported USD liquidity and 24h volume, 24h transaction count, pool creation time, and the source coverage limits. Membership discovery only: a provider-covered observation rather than a complete census, no APR and no execution support, and the asset\u2019s own 24h return is reported only from pools where it is the base token. Identify the asset by address when a ticker names two deployments on one chain \u2014 that spelling is refused rather than resolved to one of them. Not a pairing recommendation.',
+        endpointId: 'stock-pools',
+        inputSchema: stockPoolsSchema,
+        priceUsd: '0.001',
+        toQuery: stockPoolsQuery,
+    }),
 ]);
 export const TOOL_DEFINITION_BY_NAME = new Map(TOOL_DEFINITIONS.map((definition) => [definition.name, definition]));
 //# sourceMappingURL=tool-definitions.js.map