@guiie/buda-mcp 1.4.2 → 1.5.1

package/src/tools/batch_orders.ts

@@ -0,0 +1,238 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import { BudaClient, BudaApiError } from "../client.js";
+import { validateMarketId } from "../validation.js";
+import type { OrderResponse } from "../types.js";
+
+export const toolSchema = {
+  name: "place_batch_orders",
+  description:
+    "Place multiple orders sequentially on Buda.com (up to 20). " +
+    "All orders are pre-validated before any API call — a validation failure stops execution with zero orders placed. " +
+    "Partial API failures do NOT roll back already-placed orders. " +
+    "Use max_notional to cap total exposure (computed as sum of amount × limit_price for limit orders; market orders contribute 0). " +
+    "IMPORTANT: Pass confirmation_token='CONFIRM' to execute. " +
+    "Requires BUDA_API_KEY and BUDA_API_SECRET.",
+  inputSchema: {
+    type: "object" as const,
+    properties: {
+      orders: {
+        type: "array",
+        description: "Array of 1–20 orders to place.",
+        items: {
+          type: "object",
+          properties: {
+            market_id: { type: "string", description: "Market ID (e.g. 'BTC-CLP')." },
+            type: { type: "string", enum: ["Bid", "Ask"], description: "Order side." },
+            price_type: { type: "string", enum: ["limit", "market"], description: "Order type." },
+            amount: { type: "number", description: "Order size in base currency." },
+            limit_price: { type: "number", description: "Required when price_type is 'limit'." },
+          },
+          required: ["market_id", "type", "price_type", "amount"],
+        },
+      },
+      max_notional: {
+        type: "number",
+        description:
+          "Optional spending cap: total notional (sum of amount × limit_price for limit orders). " +
+          "Batch is rejected before any API call if the sum exceeds this value. " +
+          "Market orders contribute 0 to the notional since their execution price is unknown.",
+      },
+      confirmation_token: {
+        type: "string",
+        description:
+          "Safety confirmation. Must equal exactly 'CONFIRM' (case-sensitive) to execute.",
+      },
+    },
+    required: ["orders", "confirmation_token"],
+  },
+};
+
+const orderShape = z.object({
+  market_id: z.string(),
+  type: z.enum(["Bid", "Ask"]),
+  price_type: z.enum(["limit", "market"]),
+  amount: z.number().positive(),
+  limit_price: z.number().positive().optional(),
+});
+
+type SingleOrderInput = z.infer<typeof orderShape>;
+
+type BatchResult = {
+  index: number;
+  market_id: string;
+  success: boolean;
+  order?: unknown;
+  error?: string;
+  code?: number | string;
+};
+
+type BatchOrdersArgs = {
+  orders: SingleOrderInput[];
+  max_notional?: number;
+  confirmation_token: string;
+};
+
+export async function handlePlaceBatchOrders(
+  args: BatchOrdersArgs,
+  client: BudaClient,
+): Promise<{ content: Array<{ type: "text"; text: string }>; isError?: boolean }> {
+  const { orders, max_notional, confirmation_token } = args;
+
+  if (confirmation_token !== "CONFIRM") {
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            error:
+              "Orders not placed. confirmation_token must equal 'CONFIRM' to execute. " +
+              "Review all orders and set confirmation_token='CONFIRM' to proceed.",
+            code: "CONFIRMATION_REQUIRED",
+            preview: { order_count: orders.length },
+          }),
+        },
+      ],
+      isError: true,
+    };
+  }
+
+  // Pre-validate ALL orders before any API call
+  for (let i = 0; i < orders.length; i++) {
+    const order = orders[i];
+    const marketError = validateMarketId(order.market_id);
+    if (marketError) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({
+              error: `Order at index ${i}: ${marketError}`,
+              code: "INVALID_MARKET_ID",
+              index: i,
+            }),
+          },
+        ],
+        isError: true,
+      };
+    }
+    if (order.price_type === "limit" && order.limit_price === undefined) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({
+              error: `Order at index ${i}: limit_price is required when price_type is 'limit'.`,
+              code: "VALIDATION_ERROR",
+              index: i,
+            }),
+          },
+        ],
+        isError: true,
+      };
+    }
+  }
+
+  // Notional cap check (limit orders only; market orders have unknown execution price)
+  if (max_notional !== undefined) {
+    const totalNotional = orders.reduce((sum, o) => {
+      return sum + (o.price_type === "limit" && o.limit_price ? o.amount * o.limit_price : 0);
+    }, 0);
+    if (totalNotional > max_notional) {
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({
+            error: `Total notional ${totalNotional} exceeds max_notional cap of ${max_notional}. No orders were placed.`,
+            code: "NOTIONAL_CAP_EXCEEDED",
+            total_notional: totalNotional,
+            max_notional,
+          }),
+        }],
+        isError: true,
+      };
+    }
+  }
+
+  // Execute sequentially
+  const results: BatchResult[] = [];
+  for (let i = 0; i < orders.length; i++) {
+    const order = orders[i];
+    try {
+      const payload: Record<string, unknown> = {
+        type: order.type,
+        price_type: order.price_type,
+        amount: order.amount,
+      };
+      if (order.price_type === "limit") {
+        payload.limit = { price: order.limit_price, type: "gtc" };
+      }
+
+      const data = await client.post<OrderResponse>(
+        `/markets/${order.market_id.toLowerCase()}/orders`,
+        payload,
+      );
+      results.push({ index: i, market_id: order.market_id, success: true, order: data.order });
+    } catch (err) {
+      const errInfo =
+        err instanceof BudaApiError
+          ? { error: err.message, code: err.status as number | string }
+          : { error: String(err), code: "UNKNOWN" as const };
+      results.push({
+        index: i,
+        market_id: order.market_id,
+        success: false,
+        error: errInfo.error,
+        code: errInfo.code,
+      });
+    }
+  }
+
+  const succeeded = results.filter((r) => r.success).length;
+  const failed = results.filter((r) => !r.success).length;
+
+  const response: Record<string, unknown> = {
+    results,
+    total: orders.length,
+    succeeded,
+    failed,
+  };
+
+  if (failed > 0 && succeeded > 0) {
+    response.warning = "Some orders failed. Already-placed orders were NOT rolled back.";
+  }
+
+  return {
+    content: [{ type: "text", text: JSON.stringify(response, null, 2) }],
+    isError: failed > 0 && succeeded === 0 ? true : undefined,
+  };
+}
+
+export function register(server: McpServer, client: BudaClient): void {
+  server.tool(
+    toolSchema.name,
+    toolSchema.description,
+    {
+      orders: z
+        .array(orderShape)
+        .min(1)
+        .max(20)
+        .describe("Array of 1–20 orders to place."),
+      max_notional: z
+        .number()
+        .positive()
+        .optional()
+        .describe(
+          "Optional spending cap: total notional (sum of amount × limit_price for limit orders). " +
+          "Batch is rejected before any API call if the sum exceeds this value. " +
+          "Market orders contribute 0 to the notional since their execution price is unknown.",
+        ),
+      confirmation_token: z
+        .string()
+        .describe(
+          "Safety confirmation. Must equal exactly 'CONFIRM' (case-sensitive) to execute.",
+        ),
+    },
+    (args) => handlePlaceBatchOrders(args, client),
+  );
+}

package/src/tools/cancel_all_orders.ts

@@ -0,0 +1,117 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import { BudaClient, BudaApiError } from "../client.js";
+import { validateMarketId } from "../validation.js";
+import type { CancelAllOrdersResponse } from "../types.js";
+
+export const toolSchema = {
+  name: "cancel_all_orders",
+  description:
+    "Cancel all open orders on Buda.com, optionally filtered by a specific market. " +
+    "Pass market_id='*' to cancel across all markets, or a specific market ID (e.g. 'BTC-CLP'). " +
+    "IMPORTANT: This action is irreversible. Pass confirmation_token='CONFIRM' to execute. " +
+    "Requires BUDA_API_KEY and BUDA_API_SECRET.",
+  inputSchema: {
+    type: "object" as const,
+    properties: {
+      market_id: {
+        type: "string",
+        description: "Market ID (e.g. 'BTC-CLP') or '*' to cancel orders across all markets.",
+      },
+      confirmation_token: {
+        type: "string",
+        description:
+          "Safety confirmation. Must equal exactly 'CONFIRM' (case-sensitive) to execute. " +
+          "Any other value will reject the request without canceling.",
+      },
+    },
+    required: ["market_id", "confirmation_token"],
+  },
+};
+
+type CancelAllOrdersArgs = {
+  market_id: string;
+  confirmation_token: string;
+};
+
+export async function handleCancelAllOrders(
+  args: CancelAllOrdersArgs,
+  client: BudaClient,
+): Promise<{ content: Array<{ type: "text"; text: string }>; isError?: boolean }> {
+  const { market_id, confirmation_token } = args;
+
+  if (confirmation_token !== "CONFIRM") {
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            error:
+              "Orders not canceled. confirmation_token must equal 'CONFIRM' to execute. " +
+              "Review and set confirmation_token='CONFIRM' to proceed.",
+            code: "CONFIRMATION_REQUIRED",
+            preview: { market_id },
+          }),
+        },
+      ],
+      isError: true,
+    };
+  }
+
+  if (market_id !== "*") {
+    const validationError = validateMarketId(market_id);
+    if (validationError) {
+      return {
+        content: [
+          { type: "text", text: JSON.stringify({ error: validationError, code: "INVALID_MARKET_ID" }) },
+        ],
+        isError: true,
+      };
+    }
+  }
+
+  try {
+    const params =
+      market_id !== "*" ? { market_id: market_id.toLowerCase() } : undefined;
+
+    const data = await client.delete<CancelAllOrdersResponse>(`/orders`, params);
+
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({ canceled_count: data.canceled_count, market_id }),
+        },
+      ],
+    };
+  } catch (err) {
+    const msg =
+      err instanceof BudaApiError
+        ? { error: err.message, code: err.status, path: err.path }
+        : { error: String(err), code: "UNKNOWN" };
+    return {
+      content: [{ type: "text", text: JSON.stringify(msg) }],
+      isError: true,
+    };
+  }
+}
+
+export function register(server: McpServer, client: BudaClient): void {
+  server.tool(
+    toolSchema.name,
+    toolSchema.description,
+    {
+      market_id: z
+        .string()
+        .min(1)
+        .describe("Market ID (e.g. 'BTC-CLP') or '*' to cancel orders across all markets."),
+      confirmation_token: z
+        .string()
+        .describe(
+          "Safety confirmation. Must equal exactly 'CONFIRM' (case-sensitive) to execute. " +
+            "Any other value will reject the request without canceling.",
+        ),
+    },
+    (args) => handleCancelAllOrders(args, client),
+  );
+}

package/src/tools/cancel_order.ts

@@ -59,7 +59,7 @@ export async function handleCancelOrder(
 
   try {
     const data = await client.put<OrderResponse>(`/orders/${order_id}`, {
-      state: "canceling",
+      order: { state: "canceling" },
     });
 
     return {

package/src/tools/cancel_order_by_client_id.ts

@@ -0,0 +1,132 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import { BudaClient, BudaApiError } from "../client.js";
+import { flattenAmount } from "../utils.js";
+import type { OrderResponse, Order } from "../types.js";
+
+export const toolSchema = {
+  name: "cancel_order_by_client_id",
+  description:
+    "Cancel an open order by its client-assigned ID on Buda.com. " +
+    "IMPORTANT: Pass confirmation_token='CONFIRM' to execute. " +
+    "Requires BUDA_API_KEY and BUDA_API_SECRET.",
+  inputSchema: {
+    type: "object" as const,
+    properties: {
+      client_id: {
+        type: "string",
+        description: "The client ID string assigned when placing the order.",
+      },
+      confirmation_token: {
+        type: "string",
+        description:
+          "Safety confirmation. Must equal exactly 'CONFIRM' (case-sensitive) to execute. " +
+          "Any other value will reject the request without canceling.",
+      },
+    },
+    required: ["client_id", "confirmation_token"],
+  },
+};
+
+type CancelOrderByClientIdArgs = {
+  client_id: string;
+  confirmation_token: string;
+};
+
+function normalizeOrder(o: Order) {
+  const amount = flattenAmount(o.amount);
+  const originalAmount = flattenAmount(o.original_amount);
+  const tradedAmount = flattenAmount(o.traded_amount);
+  const totalExchanged = flattenAmount(o.total_exchanged);
+  const paidFee = flattenAmount(o.paid_fee);
+  const limitPrice = o.limit ? flattenAmount(o.limit) : null;
+
+  return {
+    id: o.id,
+    type: o.type,
+    state: o.state,
+    created_at: o.created_at,
+    market_id: o.market_id,
+    fee_currency: o.fee_currency,
+    price_type: o.price_type,
+    order_type: o.order_type,
+    client_id: o.client_id,
+    limit_price: limitPrice ? limitPrice.value : null,
+    limit_price_currency: limitPrice ? limitPrice.currency : null,
+    amount: amount.value,
+    amount_currency: amount.currency,
+    original_amount: originalAmount.value,
+    original_amount_currency: originalAmount.currency,
+    traded_amount: tradedAmount.value,
+    traded_amount_currency: tradedAmount.currency,
+    total_exchanged: totalExchanged.value,
+    total_exchanged_currency: totalExchanged.currency,
+    paid_fee: paidFee.value,
+    paid_fee_currency: paidFee.currency,
+  };
+}
+
+export async function handleCancelOrderByClientId(
+  args: CancelOrderByClientIdArgs,
+  client: BudaClient,
+): Promise<{ content: Array<{ type: "text"; text: string }>; isError?: boolean }> {
+  const { client_id, confirmation_token } = args;
+
+  if (confirmation_token !== "CONFIRM") {
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            error:
+              "Order not canceled. confirmation_token must equal 'CONFIRM' to execute. " +
+              "Verify the client ID and set confirmation_token='CONFIRM' to proceed.",
+            code: "CONFIRMATION_REQUIRED",
+            client_id,
+          }),
+        },
+      ],
+      isError: true,
+    };
+  }
+
+  try {
+    const data = await client.put<OrderResponse>(
+      `/orders/by-client-id/${encodeURIComponent(client_id)}`,
+      { order: { state: "canceling" } },
+    );
+
+    return {
+      content: [{ type: "text", text: JSON.stringify(normalizeOrder(data.order), null, 2) }],
+    };
+  } catch (err) {
+    const msg =
+      err instanceof BudaApiError
+        ? { error: err.message, code: err.status, path: err.path }
+        : { error: String(err), code: "UNKNOWN" };
+    return {
+      content: [{ type: "text", text: JSON.stringify(msg) }],
+      isError: true,
+    };
+  }
+}
+
+export function register(server: McpServer, client: BudaClient): void {
+  server.tool(
+    toolSchema.name,
+    toolSchema.description,
+    {
+      client_id: z
+        .string()
+        .min(1)
+        .describe("The client ID string assigned when placing the order."),
+      confirmation_token: z
+        .string()
+        .describe(
+          "Safety confirmation. Must equal exactly 'CONFIRM' (case-sensitive) to execute. " +
+            "Any other value will reject the request without canceling.",
+        ),
+    },
+    (args) => handleCancelOrderByClientId(args, client),
+  );
+}

package/src/tools/dead_mans_switch.ts

@@ -23,7 +23,7 @@ async function cancelAllOrdersForMarket(marketId: string, client: BudaClient): P
     const orders = data.orders ?? [];
     await Promise.allSettled(
       orders.map((order) =>
-        client.put<OrderResponse>(`/orders/${order.id}`, { state: "canceling" }),
+        client.put<OrderResponse>(`/orders/${order.id}`, { order: { state: "canceling" } }),
       ),
     );
     timers.delete(marketId);
@@ -155,6 +155,21 @@ export async function handleScheduleCancelAll(
     };
   }
 
+  if (!Number.isInteger(ttl_seconds) || ttl_seconds < 10 || ttl_seconds > 300) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            error: "ttl_seconds must be an integer between 10 and 300.",
+            code: "VALIDATION_ERROR",
+          }),
+        },
+      ],
+      isError: true,
+    };
+  }
+
   const id = market_id.toLowerCase();
   const entry = armTimer(id, ttl_seconds, client);
 
@@ -269,7 +284,11 @@ export function handleDisarmCancelTimer(
 
 // ---- Registration ----
 
-export function register(server: McpServer, client: BudaClient): void {
+export function register(
+  server: McpServer,
+  client: BudaClient,
+  transport: "stdio" | "http" = "stdio",
+): void {
   server.tool(
     toolSchema.name,
     toolSchema.description,
@@ -287,7 +306,24 @@ export function register(server: McpServer, client: BudaClient): void {
         .string()
         .describe("Must equal exactly 'CONFIRM' (case-sensitive) to arm the switch."),
     },
-    (args) => handleScheduleCancelAll(args, client),
+    (args) => {
+      if (transport === "http") {
+        return Promise.resolve({
+          content: [{
+            type: "text" as const,
+            text: JSON.stringify({
+              error:
+                "schedule_cancel_all is not available on the HTTP transport. " +
+                "Timer state is lost on every server restart or deploy. " +
+                "Run buda-mcp in stdio mode on a persistent local process to use this feature.",
+              code: "TRANSPORT_NOT_SUPPORTED",
+            }),
+          }],
+          isError: true,
+        });
+      }
+      return handleScheduleCancelAll(args, client);
+    },
   );
 
   server.tool(