@unhedged/mcp 0.1.2

package/dist/server.js

@@ -0,0 +1,75 @@
+import { createRequire } from 'node:module';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { UnhedgedHttpClient } from './client/http.js';
+import { UnhedgedApiError } from './client/errors.js';
+import { loadConfig } from './config.js';
+import { getAllTools } from './tools/index.js';
+import { SpendCapTracker, SpendCapExceededError } from './safety/spend-cap.js';
+import { registerSkills } from './prompts/index.js';
+const SERVER_NAME = 'unhedged-mcp';
+// package.json sits one level above both src/ and dist/, so this resolves in
+// dev (tsx) and installed builds alike.
+const SERVER_VERSION = createRequire(import.meta.url)('../package.json').version;
+export async function createServer() {
+    const config = loadConfig();
+    const client = new UnhedgedHttpClient(config);
+    const spendCap = new SpendCapTracker(config.maxSpendPerSession);
+    const context = { client, config, spendCap };
+    const server = new McpServer({
+        name: SERVER_NAME,
+        version: SERVER_VERSION,
+    });
+    for (const tool of getAllTools()) {
+        server.registerTool(tool.name, {
+            title: tool.title,
+            description: tool.description,
+            inputSchema: tool.inputSchema,
+            annotations: tool.annotations,
+        }, async (args) => {
+            try {
+                const result = await tool.handler(args, context);
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify(result, null, 2),
+                        },
+                    ],
+                };
+            }
+            catch (err) {
+                const message = err instanceof UnhedgedApiError
+                    ? err.toAgentMessage(tool.annotations.readOnlyHint !== true)
+                    : err instanceof SpendCapExceededError
+                        ? err.message
+                        : err instanceof Error
+                            ? err.message
+                            : String(err);
+                return {
+                    isError: true,
+                    content: [{ type: 'text', text: message }],
+                };
+            }
+        });
+    }
+    // Skills (MCP prompts). Failure to load is non-fatal — log to stderr and continue
+    // with tools only.
+    try {
+        const registered = registerSkills(server);
+        process.stderr.write(`[unhedged-mcp] Registered ${registered.length} skills: ${registered.join(', ')}\n`);
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        process.stderr.write(`[unhedged-mcp] Failed to register skills: ${msg}\n`);
+    }
+    if (config.maxSpendPerSession !== null) {
+        process.stderr.write(`[unhedged-mcp] Session cap: ${config.maxSpendPerSession} USD in bet stakes and buy-order notional. Excludes fees and withdrawals; resets on restart.\n`);
+    }
+    return server;
+}
+export async function startStdioServer() {
+    const server = await createServer();
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+}

package/dist/tools/balance.d.ts

@@ -0,0 +1,2 @@
+import { type AnyToolDefinition } from './types.js';
+export declare const balanceTools: AnyToolDefinition[];

package/dist/tools/balance.js

@@ -0,0 +1,175 @@
+import { z } from 'zod';
+import { defineTool, READ_ONLY } from './types.js';
+import { UnhedgedApiError } from '../client/errors.js';
+const GET_DESCRIPTION = `
+Read the user's Unhedged **platform balance** (the off-chain, CEX-style balance used for betting and order placement — distinct from their on-chain wallet balance). Platform balances and fees are denominated in **USD**. Held balances \`ccAvailable\` and \`ccLocked\` are in **CC**. \`ccPriceUsd\` is the USD price of one CC.
+
+Returns:
+\`\`\`
+{
+  balance: {
+    available,         // free to bet/order/withdraw
+    lockedBets,        // tied up in open parimutuel bets
+    lockedEngine,      // tied up in resting CLOB orders
+    lockedWithdraws,   // pending on-chain withdrawals
+    total,             // sum of the above
+    totalDeposited,
+    totalWithdrawn,
+    ccAvailable,
+    ccLocked
+  },
+  withdrawalFee,        // flat fee per withdrawal request (USD)
+  withdrawalMinAmount,  // minimum withdrawal size (USD)
+  bettingFee,           // current parimutuel fee (USD)
+  ccPriceUsd            // current CC↔USD reference, or null if unknown
+}
+\`\`\`
+
+All numeric fields except \`ccPriceUsd\` (a number or null) are returned as **strings** to preserve precision. Parse with \`Number()\` or a Decimal library as appropriate.
+
+Requires scope: \`balance:read\`.
+
+### When to use
+Before placing a bet or order, to confirm the user has the funds. After a trade, to show the new balance. Always **before** offering withdrawal options.
+`.trim();
+const WITHDRAW_DESCRIPTION = `
+Request a withdrawal from the user's platform balance to their on-chain wallet. The platform locks the amount, queues a withdrawal transaction, and settles it asynchronously.
+
+Required parameters:
+- **amount**: Decimal **USD** amount to debit from the platform balance. Send a number for the default Canton flow or a decimal string for Ethereum USDC. In the Canton flow, the USD amount is swapped to CC at the current rate (see \`ccPriceUsd\` in \`get_balance\`) before settling to the wallet — the user receives CC, not a face-value USD token.
+
+Optional:
+- **network**: \`"ETHEREUM"\` routes the withdrawal to Ethereum Mainnet. If omitted, the existing Canton flow is used.
+- **destinationAddress**: Ethereum destination address. Required when \`network\` is \`"ETHEREUM"\`.
+- **destinationPartyId**: Canton party ID for the destination. Required for web2 users without a linked Canton wallet.
+- **target**: \`"cc"\` (default) for the existing Canton flow.
+
+Fees:
+- **Canton**: a flat withdrawal fee (USD) is deducted on top of the amount (see \`withdrawalFee\` in \`get_balance\`).
+- **Ethereum**: a dynamic network fee applies. The tool automatically fetches a fee quote (\`GET /api/v1/balance/ethereum/withdraw-quote\`) and locks it into the withdrawal request — no extra input is needed. The quote is short-lived (roughly 30–120 seconds) and is consumed by the withdrawal, so it is fetched fresh on every call. If quoting fails (e.g. amount out of limits, invalid destination, fee configuration unavailable), the tool errors out and no withdrawal is submitted.
+
+Returns:
+\`\`\`
+{
+  withdrawal: { id, amount, fee, totalDeducted, status, createdAt },
+  message: "Withdrawal request submitted..."
+}
+\`\`\`
+
+The MCP server adds an \`Idempotency-Key\` automatically.
+
+Requires scope: \`balance:withdraw\`. **This scope is opt-in.** Keys minted without it can browse, bet, and trade but cannot move funds off the platform. Ethereum withdrawals additionally need \`balance:read\` on the key (for the fee-quote request).
+
+### Safety
+- Withdrawals are rate-limited server-side (typically 5 per minute per user).
+
+### Examples
+Withdraw $50 from the platform balance to the user's linked Canton wallet (delivered as CC at the current rate):
+\`\`\`json
+{ "amount": 50 }
+\`\`\`
+
+Debit $25.50 from the platform balance and send the remainder after fees as USDC on Ethereum Mainnet:
+\`\`\`json
+{ "amount": "25.5", "network": "ETHEREUM", "destinationAddress": "0x1111111111111111111111111111111111111111" }
+\`\`\`
+`.trim();
+const decimalAmount = z.union([
+    z.number().positive(),
+    z.string().regex(/^(?:0|[1-9]\d*)(?:\.\d+)?$/).refine(value => /[1-9]/.test(value), 'Amount must be positive'),
+]);
+const withdrawSchema = {
+    amount: decimalAmount.describe('Withdrawal amount in USD. Ethereum USDC accepts at most six decimal places.'),
+    network: z
+        .enum(['CANTON', 'ETHEREUM'])
+        .optional()
+        .describe('Withdrawal network. Omit this field to preserve the Canton default.'),
+    destinationAddress: z
+        .string()
+        .regex(/^0x[0-9a-fA-F]{40}$/)
+        .optional()
+        .describe('Ethereum destination address. Required when network is "ETHEREUM".'),
+    destinationPartyId: z
+        .string()
+        .optional()
+        .describe('Canton party ID. Required for web2 users with no linked Canton wallet.'),
+    target: z
+        .enum(['cc'])
+        .optional()
+        .describe('Canton asset target. Existing callers can omit this field.'),
+};
+export const balanceTools = [
+    defineTool({
+        name: 'get_balance',
+        title: 'Get platform balance',
+        description: GET_DESCRIPTION,
+        inputSchema: {},
+        annotations: READ_ONLY,
+        handler: async (_args, ctx) => {
+            return ctx.client.request({
+                method: 'GET',
+                path: '/api/v1/balance',
+            });
+        },
+    }),
+    defineTool({
+        name: 'request_withdrawal',
+        title: 'Request a withdrawal',
+        description: WITHDRAW_DESCRIPTION,
+        inputSchema: withdrawSchema,
+        // Moves funds off the platform to an agent-supplied destination.
+        annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false },
+        handler: async (args, ctx) => {
+            if (args.network === 'ETHEREUM' && !args.destinationAddress) {
+                throw new Error('destinationAddress is required for an Ethereum withdrawal');
+            }
+            if (args.network !== 'ETHEREUM' && args.destinationAddress) {
+                throw new Error('network must be "ETHEREUM" when destinationAddress is provided');
+            }
+            if (args.network === 'ETHEREUM'
+                && (typeof args.amount !== 'string'
+                    || !/^(?:0|[1-9]\d*)(?:\.\d{1,6})?$/.test(args.amount)
+                    || !/[1-9]/.test(args.amount))) {
+                throw new Error('Ethereum amount must be a positive decimal string with at most six decimal places');
+            }
+            if (args.network === 'ETHEREUM') {
+                const quoteResponse = await ctx.client.request({
+                    method: 'GET',
+                    path: '/api/v1/balance/ethereum/withdraw-quote',
+                    query: {
+                        usdAmount: String(args.amount),
+                        destinationAddress: args.destinationAddress,
+                    },
+                }).catch((error) => {
+                    if (error instanceof UnhedgedApiError) {
+                        throw new Error(`No withdrawal was submitted. ${error.toAgentMessage()}`);
+                    }
+                    throw error;
+                });
+                const quoteId = quoteResponse?.quote?.quoteId;
+                if (typeof quoteId !== 'string' || quoteId.length === 0) {
+                    throw new Error('Ethereum withdrawal quote response did not include a quoteId');
+                }
+                return ctx.client.request({
+                    method: 'POST',
+                    path: '/api/v1/balance/withdraw/ethereum',
+                    body: {
+                        amount: String(args.amount),
+                        destinationAddress: args.destinationAddress,
+                        quoteId,
+                    },
+                });
+            }
+            const cantonBody = { amount: args.amount };
+            if (args.destinationPartyId)
+                cantonBody.destinationPartyId = args.destinationPartyId;
+            if (args.target)
+                cantonBody.target = args.target;
+            return ctx.client.request({
+                method: 'POST',
+                path: '/api/v1/balance/withdraw',
+                body: cantonBody,
+            });
+        },
+    }),
+];

package/dist/tools/bets.d.ts

@@ -0,0 +1,2 @@
+import { type AnyToolDefinition } from './types.js';
+export declare const betTools: AnyToolDefinition[];

package/dist/tools/bets.js

@@ -0,0 +1,109 @@
+import { z } from 'zod';
+import { defineTool, READ_ONLY } from './types.js';
+import { UnhedgedApiError } from '../client/errors.js';
+const LIST_DESCRIPTION = `
+List the user's **parimutuel bets**. (Order-book trades show up under \`list_orders\` instead.)
+
+Filters:
+- **status**: \`PENDING | CONFIRMED | FAILED | REFUNDED | WON | LOST\`. Omit to return any status.
+- **marketId**: restrict to a single market.
+- **limit**: 1-100, default 20.
+- **offset**: pagination, default 0.
+
+Returns \`{ bets, total }\`. Each bet has \`id\`, \`marketId\`, \`outcomeIndex\`, \`amount\` (string, USD), \`status\`, \`timeWeight\`, \`createdAt\`.
+
+Requires scope: \`bet:read\`.
+
+### Examples
+All bets on a specific market:
+\`\`\`json
+{ "marketId": "clxabc123..." }
+\`\`\`
+
+Only winning bets, most recent first:
+\`\`\`json
+{ "status": "WON", "limit": 50 }
+\`\`\`
+`.trim();
+const PLACE_DESCRIPTION = `
+Place a **parimutuel bet** on a market outcome. This is the simple "pool" market type — the user picks an outcome, commits USD from their platform balance, and shares the winning pool pro-rata if their outcome resolves. For order-book (CLOB) markets, use \`place_order\` instead.
+
+Required parameters:
+- **marketId**: ID of the market to bet on.
+- **outcomeIndex**: zero-indexed outcome. Look up valid outcomes via \`get_market\` first; passing an out-of-range index will be rejected.
+- **amount**: Stake in USD, at least the market's minimum bet (typically $1). The fee is charged on top: stake plus fee must fit within the user's available platform balance.
+
+The MCP server attaches an \`Idempotency-Key\` header, but deliberately does **not** retry an ambiguous failure automatically. Do **not** immediately re-invoke this tool after a network error or timeout — a new call uses a new key and can place a duplicate bet. Check \`list_bets\` for the result. If the outcome remains uncertain, stop and ask the user before retrying.
+
+Returns:
+\`\`\`
+{ bet: { id, marketId, outcomeIndex, amount, status }, balanceAfter, fee }
+\`\`\`
+
+Requires scope: \`bet:place\`.
+
+### Safety
+- If a **session spend cap** is configured, the \`amount\` adds to the running total; once exceeded, further calls refuse until the server restarts or the cap is raised.
+
+### Example
+Bet $10 on outcome 0 (typically YES on a binary market):
+\`\`\`json
+{ "marketId": "clxabc123...", "outcomeIndex": 0, "amount": 10 }
+\`\`\`
+`.trim();
+const listSchema = {
+    status: z.enum(['PENDING', 'CONFIRMED', 'FAILED', 'REFUNDED', 'WON', 'LOST']).optional(),
+    marketId: z.string().optional(),
+    limit: z.number().int().min(1).max(100).optional(),
+    offset: z.number().int().min(0).optional(),
+};
+const placeSchema = {
+    marketId: z.string().min(1).describe('Market ID to bet on.'),
+    outcomeIndex: z.number().int().min(0).describe('Zero-indexed outcome to bet on.'),
+    amount: z
+        .number()
+        .positive()
+        .describe('USD amount to commit. Must be within available platform balance.'),
+};
+export const betTools = [
+    defineTool({
+        name: 'list_bets',
+        title: 'List user bets',
+        description: LIST_DESCRIPTION,
+        inputSchema: listSchema,
+        annotations: READ_ONLY,
+        handler: async (args, ctx) => {
+            return ctx.client.request({
+                method: 'GET',
+                path: '/api/v1/bets',
+                query: args,
+            });
+        },
+    }),
+    defineTool({
+        name: 'place_bet',
+        title: 'Place a parimutuel bet',
+        description: PLACE_DESCRIPTION,
+        inputSchema: placeSchema,
+        annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: false, openWorldHint: false },
+        handler: async (args, ctx) => {
+            ctx.spendCap.reserve(args.amount, 'place_bet');
+            try {
+                return await ctx.client.request({
+                    method: 'POST',
+                    path: '/api/v1/bets',
+                    body: { marketId: args.marketId, outcomeIndex: args.outcomeIndex, amount: args.amount },
+                });
+            }
+            catch (err) {
+                // A 4xx means the server definitively rejected the bet, so nothing was
+                // spent — give the reservation back. Ambiguous outcomes (network
+                // errors, 5xx) keep it, erring on the side of capping too much.
+                if (err instanceof UnhedgedApiError && err.status >= 400 && err.status < 500) {
+                    ctx.spendCap.release(args.amount);
+                }
+                throw err;
+            }
+        },
+    }),
+];

package/dist/tools/index.d.ts

@@ -0,0 +1,4 @@
+import type { AnyToolDefinition } from './types.js';
+export declare function getAllTools(): AnyToolDefinition[];
+export { defineTool } from './types.js';
+export type { AnyToolDefinition, ToolDefinition, ToolContext } from './types.js';

package/dist/tools/index.js

@@ -0,0 +1,17 @@
+import { marketTools } from './markets.js';
+import { balanceTools } from './balance.js';
+import { portfolioTools } from './portfolio.js';
+import { betTools } from './bets.js';
+import { orderTools } from './orders.js';
+import { marketMakerTools } from './market-maker.js';
+export function getAllTools() {
+    return [
+        ...marketTools,
+        ...balanceTools,
+        ...portfolioTools,
+        ...betTools,
+        ...orderTools,
+        ...marketMakerTools,
+    ];
+}
+export { defineTool } from './types.js';

package/dist/tools/market-maker.d.ts

@@ -0,0 +1,2 @@
+import { type AnyToolDefinition } from './types.js';
+export declare const marketMakerTools: AnyToolDefinition[];

package/dist/tools/market-maker.js

@@ -0,0 +1,38 @@
+import { defineTool, READ_ONLY } from './types.js';
+const PROFILE_DESCRIPTION = `
+Fetch the **market-maker profile** for the API key's user. **Call this first** before running the market-maker workflow — it tells you the live economics the agent is operating under.
+
+Returns the user's market-maker self view, including:
+- **approvalStatus** (\`PENDING | APPROVED | SUSPENDED\`) — only \`APPROVED\` MMs get elevated limits and MM fees.
+- **feeMode** (\`VOLUME | MANUAL\`) and **currentTier** — the active MM fee tier.
+- **effectiveMakerFee** / **effectiveTakerFee** — the resolved signed fee rates at the current tier. Per-contract fee is \`price × (1 − price) × rate\`.
+- **rateLimitProfile** and **orderRateLimit** — how many orders/min this account may place (MMs run on the \`market_maker\` preset).
+- **exposure** / **exposureCap** — current net exposure and the (reporting-only) cap.
+- **rebateRate** — fraction of maker notional paid back as a liquidity rebate.
+- identity fields (\`entityName\`, \`contactEmail\`, \`website\`, \`jurisdiction\`, \`strategyNotes\`) and **recentRebates**.
+
+This only works for accounts with the \`MARKET_MAKER\` role; a regular account gets a 403.
+
+Requires scope: \`portfolio:read\`.
+
+### Example
+No arguments:
+\`\`\`json
+{}
+\`\`\`
+`.trim();
+export const marketMakerTools = [
+    defineTool({
+        name: 'get_market_maker_profile',
+        title: 'Get market maker profile',
+        description: PROFILE_DESCRIPTION,
+        inputSchema: {},
+        annotations: READ_ONLY,
+        handler: async (_args, ctx) => {
+            return ctx.client.request({
+                method: 'GET',
+                path: '/api/v1/market-maker/me',
+            });
+        },
+    }),
+];

package/dist/tools/markets.d.ts

@@ -0,0 +1,2 @@
+import { type AnyToolDefinition } from './types.js';
+export declare const marketTools: AnyToolDefinition[];

package/dist/tools/markets.js

@@ -0,0 +1,120 @@
+import { z } from 'zod';
+import { defineTool, READ_ONLY } from './types.js';
+const SEARCH_DESCRIPTION = `
+List and search Unhedged prediction markets. Use this when the user asks about what markets exist, what they can bet on, what the odds are on a topic, or which markets are open right now.
+
+Filter behaviour:
+- **search**: free-text matched against the market question, tags, and category. Terms of four or more characters also match the description. Use this for topical queries like "election", "BTC price", "Lakers".
+- **status**: filter by lifecycle. \`ACTIVE\` means open for trading, \`ENDED\` means closed but not yet resolved, \`RESOLVED\` means winners paid out, \`VOIDED\` means cancelled. Omit to include ACTIVE + ENDED. Request RESOLVED or VOIDED explicitly for historical markets.
+- **category**: e.g. "crypto", "sports", "politics", "esports".
+- **tag**: filter by one tag.
+- **tags**: array of tags; markets must match ALL supplied tags.
+- **orderBy**: one of \`createdAt\`, \`endTime\`, \`totalPool\`, \`question\`, \`status\`, \`betCount\`, \`payoutPool\`. Default \`createdAt\`.
+- **orderDirection**: \`asc\` or \`desc\`. Default \`desc\`.
+- **limit**: 1-100, default 20.
+- **offset**: pagination, default 0.
+
+Returns \`{ markets: MarketSummary[], total: number }\`. Each summary has \`id\`, \`question\`, \`status\`, \`outcomes\` (with labels), \`totalPool\`, \`endTime\`, plus category/tags metadata.
+
+This endpoint is **public** — no API key scope required.
+
+### Example
+Find the five most-recent active crypto markets:
+\`\`\`json
+{ "status": "ACTIVE", "category": "crypto", "limit": 5 }
+\`\`\`
+`.trim();
+const GET_MARKET_DESCRIPTION = `
+Fetch the full record for a single market by ID. Call this after \`search_markets\` once you've narrowed down a candidate, or whenever you need the detailed outcome list / resolution rules / live event data.
+
+Returns \`{ market }\` with all outcomes (labels + indexes), pool sizes per outcome, scheduled resolution time, auto-resolution config, optional live event data (sports), and an OG image URL for sharing.
+
+Public — no scope required.
+
+### Example
+\`\`\`json
+{ "id": "clxabc123..." }
+\`\`\`
+`.trim();
+const GET_STATS_DESCRIPTION = `
+Get market statistics: current implied probabilities per outcome, volume, bet count, payout pool, and time-weighted odds history pointers. Use this to compute edge, present odds to the user, or feed inputs to a hedged-position calculator.
+
+Returns \`{ stats }\`. Stats shape mirrors the backend response and varies slightly by market type (PARIMUTUEL vs CLOB).
+
+Public — no scope required.
+
+### Example
+\`\`\`json
+{ "id": "clxabc123..." }
+\`\`\`
+`.trim();
+const searchSchema = {
+    status: z.enum(['ACTIVE', 'ENDED', 'RESOLVED', 'VOIDED']).optional(),
+    category: z.string().optional(),
+    tag: z.string().max(50).optional(),
+    tags: z
+        .array(z.string().min(1).max(50))
+        .max(20)
+        .refine((tags) => tags.join(',').length <= 500, 'Combined tags must be at most 500 characters.')
+        .optional(),
+    search: z.string().min(2).max(200).optional(),
+    orderBy: z
+        .enum(['createdAt', 'endTime', 'totalPool', 'question', 'status', 'betCount', 'payoutPool'])
+        .optional(),
+    orderDirection: z.enum(['asc', 'desc']).optional(),
+    limit: z.number().int().min(1).max(100).optional(),
+    offset: z.number().int().min(0).optional(),
+};
+const idSchema = {
+    id: z.string().min(1).describe('Market ID (e.g. "clxabc123...")'),
+};
+export const marketTools = [
+    defineTool({
+        name: 'search_markets',
+        title: 'Search prediction markets',
+        description: SEARCH_DESCRIPTION,
+        inputSchema: searchSchema,
+        annotations: READ_ONLY,
+        handler: async (args, ctx) => {
+            const { tags, status, ...query } = args;
+            return ctx.client.request({
+                method: 'GET',
+                path: '/api/v1/markets',
+                // The REST API accepts one comma-separated `tags` value and applies
+                // hasEvery semantics. Keep the MCP input ergonomic while honoring that
+                // wire contract.
+                query: {
+                    ...query,
+                    status: status ?? 'ACTIVE,ENDED',
+                    tags: tags && tags.length > 0 ? tags.join(',') : undefined,
+                },
+            });
+        },
+    }),
+    defineTool({
+        name: 'get_market',
+        title: 'Get market by ID',
+        description: GET_MARKET_DESCRIPTION,
+        inputSchema: idSchema,
+        annotations: READ_ONLY,
+        handler: async (args, ctx) => {
+            return ctx.client.request({
+                method: 'GET',
+                path: `/api/v1/markets/${encodeURIComponent(args.id)}`,
+            });
+        },
+    }),
+    defineTool({
+        name: 'get_market_stats',
+        title: 'Get market statistics',
+        description: GET_STATS_DESCRIPTION,
+        inputSchema: idSchema,
+        annotations: READ_ONLY,
+        handler: async (args, ctx) => {
+            return ctx.client.request({
+                method: 'GET',
+                path: `/api/v1/markets/${encodeURIComponent(args.id)}/stats`,
+            });
+        },
+    }),
+];

package/dist/tools/orders.d.ts

@@ -0,0 +1,2 @@
+import { type AnyToolDefinition } from './types.js';
+export declare const orderTools: AnyToolDefinition[];