@t2000/engine 0.46.5 → 0.46.7

package/dist/index.d.ts

@@ -922,6 +922,32 @@ declare class QueryEngine {
     reset(): void;
     getGuardEvents(): readonly GuardEvent[];
     loadMessages(messages: Message[]): void;
+    /**
+     * [v0.46.7] Run a read-only tool out-of-band, using the engine's tool
+     * registry and ToolContext. Used by hosts to deterministically pre-dispatch
+     * tools based on user-message intent (e.g. always call `balance_check` when
+     * the user says "what's my net worth?", regardless of whether the LLM would
+     * have otherwise re-called it).
+     *
+     * The host is responsible for:
+     *  - Streaming the synthetic `tool_start` + `tool_result` events to the UI
+     *    (so cards render as if the LLM had called the tool).
+     *  - Appending matching `tool_use` + `tool_result` ContentBlocks to the
+     *    engine's message history via `loadMessages([...getMessages(), ...synth])`
+     *    BEFORE calling `submitMessage`, so the LLM sees the fresh data and
+     *    doesn't re-call.
+     *
+     * Throws if the tool isn't registered, isn't read-only, or fails input
+     * validation. Tool execution errors are returned as `{ data, isError: true }`
+     * for the caller to handle (typically: skip the injection so the LLM falls
+     * back to its normal flow).
+     */
+    invokeReadTool(toolName: string, input: unknown, options?: {
+        signal?: AbortSignal;
+    }): Promise<{
+        data: unknown;
+        isError: boolean;
+    }>;
     setServerPositions(data: EngineConfig['serverPositions']): void;
     getUsage(): CostSnapshot;
     /**
@@ -1644,12 +1670,23 @@ declare const healthCheckTool: Tool<{}, {
     status: string;
 }>;
 
-declare const ratesInfoTool: Tool<{}, _t2000_sdk.RatesResult>;
+type RateMap = Record<string, {
+    saveApy: number;
+    borrowApy: number;
+}>;
+declare const ratesInfoTool: Tool<{
+    assets?: string[] | undefined;
+    stableOnly?: boolean | undefined;
+    topN?: number | undefined;
+}, RateMap>;
 
 declare const transactionHistoryTool: Tool<{
     action?: "send" | "swap" | "transaction" | "lending" | undefined;
     date?: string | undefined;
+    direction?: "out" | "in" | undefined;
     limit?: number | undefined;
+    minUsd?: number | undefined;
+    assetSymbol?: string | undefined;
 }, Record<string, unknown>>;
 
 declare const saveDepositTool: Tool<{
@@ -1743,6 +1780,7 @@ declare const payApiTool: Tool<{
 declare const mppServicesTool: Tool<{
     query?: string | undefined;
     category?: string | undefined;
+    mode?: "summary" | "full" | undefined;
 }, Record<string, unknown>>;
 
 declare const swapExecuteTool: Tool<{
@@ -1930,6 +1968,7 @@ declare const activitySummaryTool: Tool<{
 }, ActivitySummary>;
 
 declare const defillamaYieldPoolsTool: Tool<{
+    stableOnly?: boolean | undefined;
     limit?: number | undefined;
     chain?: string | undefined;
     project?: string | undefined;

package/dist/index.js

@@ -977,6 +977,36 @@ var healthCheckTool = buildTool({
   }
 });
 var YIELDS_API = "https://yields.llama.fi";
+var STABLECOIN_SYMBOLS2 = /* @__PURE__ */ new Set([
+  "usdc",
+  "wusdc",
+  "usdt",
+  "wusdt",
+  "suiusdt",
+  "usdy",
+  "usdsui",
+  "usde",
+  "ausd",
+  "fdusd",
+  "buck"
+]);
+function isStable(symbol) {
+  return STABLECOIN_SYMBOLS2.has(symbol.toLowerCase());
+}
+function applyFilters(rates, opts) {
+  let entries = Object.entries(rates);
+  if (opts.assets && opts.assets.length) {
+    const wanted = new Set(opts.assets.map((a) => a.toLowerCase()));
+    entries = entries.filter(([sym]) => wanted.has(sym.toLowerCase()));
+  } else if (opts.stableOnly) {
+    entries = entries.filter(([sym]) => isStable(sym));
+  }
+  entries.sort(([, a], [, b]) => b.saveApy - a.saveApy);
+  if (opts.topN && opts.topN > 0) {
+    entries = entries.slice(0, opts.topN);
+  }
+  return Object.fromEntries(entries);
+}
 function formatRatesSummary(rates) {
   return Object.entries(rates).map(([asset, r]) => `${asset}: Save ${(r.saveApy * 100).toFixed(2)}% / Borrow ${(r.borrowApy * 100).toFixed(2)}%`).join(", ");
 }
@@ -997,22 +1027,52 @@ async function fetchRatesFromDefiLlama() {
 }
 var ratesInfoTool = buildTool({
   name: "rates_info",
-  description: "Get current NAVI Protocol lending/savings rates (APY) for supported assets on Sui. Returns save APY and borrow APY per asset.",
-  inputSchema: z.object({}),
-  jsonSchema: { type: "object", properties: {}, required: [] },
+  description: 'NAVI Protocol lending markets ONLY (single-sided save/borrow, no impermanent-loss risk). Use this for stablecoin and bluechip lending yields. Renders a rich rates card. Filter args: `assets` (specific symbols like ["USDC"]), `stableOnly` (true to show only USD-pegged assets), `topN` (max rows in card, default 8, max 50). Do NOT call defillama_yield_pools in the same turn \u2014 that tool is for LP/farming pools with IL risk, not lending.',
+  inputSchema: z.object({
+    assets: z.array(z.string()).optional().describe('Filter to specific asset symbols (e.g. ["USDC"], ["USDC","USDT","USDSUI"]). Case-insensitive.'),
+    stableOnly: z.boolean().optional().describe("When true, return only stablecoin markets (USDC, USDT, USDSUI, USDY, suiUSDT, etc.). Ignored when `assets` is supplied."),
+    topN: z.number().int().min(1).max(50).optional().describe("Cap the number of rows in the card (default 8). Use 50 to render the full NAVI catalog.")
+  }),
+  jsonSchema: {
+    type: "object",
+    properties: {
+      assets: {
+        type: "array",
+        items: { type: "string" },
+        description: "Filter to specific asset symbols (case-insensitive)."
+      },
+      stableOnly: {
+        type: "boolean",
+        description: "When true, return only stablecoin markets. Ignored when `assets` is supplied."
+      },
+      topN: {
+        type: "number",
+        description: "Cap the number of rows in the card (default 8, max 50)."
+      }
+    },
+    required: []
+  },
   isReadOnly: true,
-  async call(_input, context) {
+  async call(input, context) {
+    const opts = {
+      assets: input.assets,
+      stableOnly: input.stableOnly,
+      topN: input.topN ?? 8
+    };
     if (hasNaviMcpGlobal(context)) {
-      const rates2 = await fetchRates(getMcpManager(context));
-      return { data: rates2, displayText: formatRatesSummary(rates2) };
+      const all2 = await fetchRates(getMcpManager(context));
+      const filtered2 = applyFilters(all2, opts);
+      return { data: filtered2, displayText: formatRatesSummary(filtered2) };
     }
     if (hasAgent(context)) {
       const agent = requireAgent(context);
-      const rates2 = await agent.rates();
-      return { data: rates2, displayText: formatRatesSummary(rates2) };
+      const all2 = await agent.rates();
+      const filtered2 = applyFilters(all2, opts);
+      return { data: filtered2, displayText: formatRatesSummary(filtered2) };
     }
-    const rates = await fetchRatesFromDefiLlama();
-    return { data: rates, displayText: formatRatesSummary(rates) };
+    const all = await fetchRatesFromDefiLlama();
+    const filtered = applyFilters(all, opts);
+    return { data: filtered, displayText: formatRatesSummary(filtered) };
   }
 });
 function parseRpcTx(tx, address) {
@@ -1114,11 +1174,14 @@ var HISTORY_ACTIONS = ["send", "lending", "swap", "transaction"];
 var DEFAULT_LOOKBACK_DAYS = 30;
 var transactionHistoryTool = buildTool({
   name: "transaction_history",
-  description: "Retrieve recent transaction history (last 30 days by default): sends, saves, withdrawals, borrows, repayments, and rewards claims. Pass `date` (YYYY-MM-DD) for a specific day, `action` to filter by category (send/lending/swap), or both.",
+  description: 'Retrieve recent transaction history (last 30 days by default): sends, saves, withdrawals, borrows, repayments, swaps, and rewards claims. Renders a rich transaction card. Filter args: `date` (YYYY-MM-DD), `action` (send/lending/swap), `minUsd` (minimum amount in USD \u2014 use this for "transactions over $X" instead of post-filtering), `assetSymbol` (e.g. "USDC", "SUI"), `direction` ("in" or "out"). The card itself respects all filters \u2014 never re-list the rows in narration.',
   inputSchema: z.object({
     limit: z.number().int().min(1).max(50).optional(),
     date: z.string().optional().describe("Specific date to search for transactions (YYYY-MM-DD format). Paginates back to find that day."),
-    action: z.enum(HISTORY_ACTIONS).optional().describe("Filter by action: send, lending, swap, or transaction.")
+    action: z.enum(HISTORY_ACTIONS).optional().describe("Filter by action: send, lending, swap, or transaction."),
+    minUsd: z.number().min(0).optional().describe('Minimum transaction amount in USD. Use this for "transactions over $X" \u2014 the amount is converted to USD using the asset price snapshot.'),
+    assetSymbol: z.string().optional().describe('Filter to a single asset symbol (case-insensitive, e.g. "USDC", "SUI", "LOFI"). Matches `tx.asset` exactly.'),
+    direction: z.enum(["in", "out"]).optional().describe('Filter by user-side balance flow: "in" = received, "out" = spent.')
   }),
   jsonSchema: {
     type: "object",
@@ -1135,6 +1198,19 @@ var transactionHistoryTool = buildTool({
         type: "string",
         enum: [...HISTORY_ACTIONS],
         description: "Filter results by action category: send, lending, swap, or transaction."
+      },
+      minUsd: {
+        type: "number",
+        description: 'Minimum transaction amount in USD. Use this for "transactions over $X" queries.'
+      },
+      assetSymbol: {
+        type: "string",
+        description: 'Filter to a single asset symbol (case-insensitive, e.g. "USDC", "SUI").'
+      },
+      direction: {
+        type: "string",
+        enum: ["in", "out"],
+        description: 'Filter by direction of user balance change: "in" = received, "out" = spent.'
       }
     }
   },
@@ -1183,17 +1259,48 @@ var transactionHistoryTool = buildTool({
   async call(input, context) {
     const limit = input.limit ?? 10;
     const action = input.action;
+    const assetSymbol = input.assetSymbol?.toLowerCase();
+    const direction = input.direction;
+    const minUsd = input.minUsd;
+    const prices = context.tokenPrices;
+    const priceFor = (sym) => {
+      if (!sym || !prices) return void 0;
+      return prices[sym.toUpperCase()] ?? prices[sym.toLowerCase()] ?? prices[sym];
+    };
     const finalize = (records2) => {
       let scoped = records2;
       if (action) scoped = scoped.filter((r) => r.action === action);
+      if (assetSymbol) {
+        scoped = scoped.filter((r) => r.asset?.toLowerCase() === assetSymbol);
+      }
+      if (direction) {
+        scoped = scoped.filter((r) => r.direction === direction);
+      }
+      if (minUsd != null && minUsd > 0) {
+        scoped = scoped.filter((r) => {
+          if (r.amount == null) return false;
+          const sym = r.asset?.toUpperCase() ?? "";
+          const isStableLike = sym === "USDC" || sym === "USDT" || sym === "WUSDC" || sym === "WUSDT" || sym === "SUIUSDT" || sym === "USDY" || sym === "USDSUI" || sym === "USDE" || sym === "AUSD" || sym === "FDUSD" || sym === "BUCK";
+          const usd = isStableLike ? r.amount : (priceFor(sym) ?? 0) * r.amount;
+          if (!isStableLike && priceFor(sym) == null) return true;
+          return usd >= minUsd;
+        });
+      }
       return scoped.slice(0, limit);
     };
+    const filterMeta = {
+      date: input.date ?? null,
+      action: action ?? null,
+      minUsd: minUsd ?? null,
+      assetSymbol: input.assetSymbol ?? null,
+      direction: direction ?? null
+    };
     if (context.agent) {
       const agent = requireAgent(context);
       const records2 = await agent.history({ limit: input.date ? limit : Math.max(limit * 4, 50) });
       const filtered2 = finalize(records2);
       return {
-        data: { transactions: filtered2, count: filtered2.length, date: input.date ?? null, action: action ?? null },
+        data: { transactions: filtered2, count: filtered2.length, ...filterMeta },
         displayText: `${filtered2.length} recent transaction(s)`
       };
     }
@@ -1210,7 +1317,7 @@ var transactionHistoryTool = buildTool({
       const filtered2 = finalize(records2);
       const dateLabel = new Date(input.date).toLocaleDateString("en-US", { month: "long", day: "numeric", year: "numeric" });
       return {
-        data: { transactions: filtered2, count: filtered2.length, date: input.date, action: action ?? null },
+        data: { transactions: filtered2, count: filtered2.length, ...filterMeta },
         displayText: filtered2.length > 0 ? `${filtered2.length} transaction(s) on ${dateLabel}` : `No transactions found on ${dateLabel}`
       };
     }
@@ -1226,8 +1333,7 @@ var transactionHistoryTool = buildTool({
       data: {
         transactions: filtered,
         count: filtered.length,
-        date: null,
-        action: action ?? null,
+        ...filterMeta,
         lookbackDays: DEFAULT_LOOKBACK_DAYS
       },
       displayText: `${filtered.length} transaction(s) in the last ${DEFAULT_LOOKBACK_DAYS} days`
@@ -1604,16 +1710,31 @@ async function fetchCatalog() {
   catalogCache = { data, ts: Date.now() };
   return data;
 }
+function renderServices(catalog) {
+  return catalog.map((s) => ({
+    id: s.id,
+    name: s.name,
+    description: s.description,
+    categories: s.categories,
+    endpoints: s.endpoints.map((e) => ({
+      url: `${MPP_GATEWAY2}/${s.id}${e.path}`,
+      method: e.method,
+      description: e.description,
+      price: `$${e.price}`
+    }))
+  }));
+}
 function matchesQuery(service, q) {
   const lower = q.toLowerCase();
   return service.id.toLowerCase().includes(lower) || service.name.toLowerCase().includes(lower) || service.description.toLowerCase().includes(lower) || service.categories.some((c) => c.toLowerCase().includes(lower)) || service.endpoints.some((e) => e.description.toLowerCase().includes(lower));
 }
 var mppServicesTool = buildTool({
   name: "mpp_services",
-  description: "Discover available MPP gateway services. Returns service names, descriptions, endpoints with required parameters, and pricing. Pass `query` for keyword search or `category` to filter by category. Calling with NO filters returns a category summary (not the full catalog) \u2014 narrow first, then fetch endpoints. Use this BEFORE calling pay_api.",
+  description: 'Discover available MPP gateway services. Returns service names, descriptions, endpoints with required parameters, and pricing. Use BEFORE calling pay_api. With no args, returns the FULL catalog as a single card (default behavior \u2014 covers "show me available MPP services", "what services exist", "show me all MPP services"). Use `query` to keyword-search a specific need ("translate", "weather", "postcard"). Use `category` to filter to one category. Use `mode: "summary"` only if you explicitly want a category-counts overview without the full list.',
   inputSchema: z.object({
-    query: z.string().optional().describe('Filter by keyword (e.g. "postcard", "translate", "weather").'),
-    category: z.string().optional().describe('Filter by category exactly (e.g. "weather", "image"). See category summary returned when called without filters.')
+    query: z.string().optional().describe('Filter by keyword (e.g. "postcard", "translate", "weather"). Returns matching services in one card.'),
+    category: z.string().optional().describe('Filter by category exactly (e.g. "weather", "image"). Use mode:"summary" first if you need to see the category list.'),
+    mode: z.enum(["summary", "full"]).optional().describe('"full" (default) returns the entire catalog in one card. "summary" returns category counts only \u2014 use this only when the user explicitly asks for a category overview.')
   }),
   jsonSchema: {
     type: "object",
@@ -1625,15 +1746,30 @@ var mppServicesTool = buildTool({
       category: {
         type: "string",
         description: 'Filter by category exactly (e.g. "weather", "image").'
+      },
+      mode: {
+        type: "string",
+        enum: ["summary", "full"],
+        description: '"full" (default) returns the entire catalog in one card. "summary" returns category counts only.'
       }
     },
     required: []
   },
   isReadOnly: true,
-  maxResultSizeChars: 5e3,
+  // [v0.46.6] Bumped to fit the full catalog (~40 services) in one
+  // shot when `mode: 'full'` is used. The summarizeOnTruncate path
+  // still applies if the catalog ever exceeds the budget.
+  maxResultSizeChars: 12e3,
   async call(input) {
     const catalog = await fetchCatalog();
-    if (!input.query && !input.category) {
+    if (input.mode !== "summary" && !input.query && !input.category) {
+      const services2 = renderServices(catalog);
+      return {
+        data: { services: services2, total: services2.length, mode: "full" },
+        displayText: `Full MPP catalog: ${services2.length} services.`
+      };
+    }
+    if (input.mode === "summary" && !input.query && !input.category) {
       const counts = /* @__PURE__ */ new Map();
       for (const svc of catalog) {
         for (const cat of svc.categories) {
@@ -1644,13 +1780,14 @@ var mppServicesTool = buildTool({
       return {
         data: {
           _refine: {
-            reason: "MPP catalog has many services \u2014 pick a category or supply a query first.",
-            suggestedParams: { category: categories[0]?.category ?? "weather" }
+            reason: 'Category summary (mode:"summary"). Re-call with a category or omit mode for the full catalog.',
+            suggestedParams: { category: categories[0]?.category ?? "weather" },
+            allModes: ["summary", "full"]
           },
           categories,
           totalServices: catalog.length
         },
-        displayText: `${catalog.length} services across ${categories.length} categories. Re-call with a category or query.`
+        displayText: `${catalog.length} services across ${categories.length} categories.`
       };
     }
     let filtered = catalog;
@@ -1661,18 +1798,7 @@ var mppServicesTool = buildTool({
     if (input.query) {
       filtered = filtered.filter((s) => matchesQuery(s, input.query));
     }
-    const services = filtered.map((s) => ({
-      id: s.id,
-      name: s.name,
-      description: s.description,
-      categories: s.categories,
-      endpoints: s.endpoints.map((e) => ({
-        url: `${MPP_GATEWAY2}/${s.id}${e.path}`,
-        method: e.method,
-        description: e.description,
-        price: `$${e.price}`
-      }))
-    }));
+    const services = renderServices(filtered);
     const filterDesc = [
       input.query ? `query "${input.query}"` : null,
       input.category ? `category "${input.category}"` : null
@@ -2933,22 +3059,44 @@ function fmtToolTvl(tvl) {
   if (tvl >= 1e3) return `$${(tvl / 1e3).toFixed(0)}K`;
   return `$${tvl}`;
 }
+var POOL_STABLE_LEGS = /* @__PURE__ */ new Set([
+  "USDC",
+  "WUSDC",
+  "USDT",
+  "WUSDT",
+  "SUIUSDT",
+  "USDY",
+  "USDSUI",
+  "USDE",
+  "AUSD",
+  "FDUSD",
+  "BUCK",
+  "DAI",
+  "LUSD",
+  "FRAX",
+  "GUSD",
+  "PYUSD",
+  "USDS",
+  "CRVUSD"
+]);
 var defillamaYieldPoolsTool = buildTool({
   name: "defillama_yield_pools",
-  description: 'Get top DeFi yield pools across protocols. Filter by chain (e.g. "Sui"), project (e.g. "navi-lending"), and minimum TVL. For NAVI lending rates, use project "navi-lending".',
+  description: 'Cross-protocol LP / vault yields with IMPERMANENT-LOSS RISK (Cetus, Bluefin, Full Sail, etc.). ONLY call when the user explicitly asks about LP pools, DeFi farming, or "higher yield with more risk". For safe single-sided lending yields (USDC save, NAVI, etc.) use rates_info instead \u2014 NEVER both in the same turn. Filter by chain (e.g. "Sui"), project, and minimum TVL.',
   inputSchema: z.object({
     chain: z.string().optional().describe('Filter by chain name (e.g. "Sui", "Ethereum")'),
-    project: z.string().optional().describe('Filter by protocol project name (e.g. "navi-lending", "cetus-clmm")'),
+    project: z.string().optional().describe('Filter by protocol project name (e.g. "cetus-clmm", "bluefin-spot")'),
     limit: z.number().min(1).max(20).optional().describe("Max results (default 5)"),
-    minTvl: z.number().optional().describe("Minimum TVL in USD to filter out small/risky pools (default 100000)")
+    minTvl: z.number().optional().describe("Minimum TVL in USD to filter out small/risky pools (default 100000)"),
+    stableOnly: z.boolean().optional().describe('When true, only return pools where every leg is a stablecoin (USDC, USDT, USDSUI, etc.). Use this for "show stablecoin yield options" \u2014 keeps volatile-pair LPs (WAL-SUI, DEEP-SUI) out.')
   }),
   jsonSchema: {
     type: "object",
     properties: {
       chain: { type: "string", description: "Filter by chain name" },
-      project: { type: "string", description: 'Filter by protocol project name (e.g. "navi-lending")' },
+      project: { type: "string", description: 'Filter by protocol project name (e.g. "cetus-clmm")' },
       limit: { type: "number", description: "Max results (default 5)" },
-      minTvl: { type: "number", description: "Minimum TVL in USD (default 100000)" }
+      minTvl: { type: "number", description: "Minimum TVL in USD (default 100000)" },
+      stableOnly: { type: "boolean", description: "When true, only return all-stablecoin pools." }
     },
     required: []
   },
@@ -2984,6 +3132,12 @@ var defillamaYieldPoolsTool = buildTool({
     }
     const minTvl = input.minTvl ?? 1e5;
     pools = pools.filter((p) => p.tvlUsd >= minTvl);
+    if (input.stableOnly) {
+      pools = pools.filter((p) => {
+        const legs = p.symbol.split("-");
+        return legs.every((leg) => POOL_STABLE_LEGS.has(leg.trim().toUpperCase()));
+      });
+    }
     pools.sort((a, b) => b.apy - a.apy);
     const limit = input.limit ?? 5;
     const top = pools.slice(0, limit);
@@ -4433,6 +4587,62 @@ var QueryEngine = class {
   loadMessages(messages) {
     this.messages = [...messages];
   }
+  /**
+   * [v0.46.7] Run a read-only tool out-of-band, using the engine's tool
+   * registry and ToolContext. Used by hosts to deterministically pre-dispatch
+   * tools based on user-message intent (e.g. always call `balance_check` when
+   * the user says "what's my net worth?", regardless of whether the LLM would
+   * have otherwise re-called it).
+   *
+   * The host is responsible for:
+   *  - Streaming the synthetic `tool_start` + `tool_result` events to the UI
+   *    (so cards render as if the LLM had called the tool).
+   *  - Appending matching `tool_use` + `tool_result` ContentBlocks to the
+   *    engine's message history via `loadMessages([...getMessages(), ...synth])`
+   *    BEFORE calling `submitMessage`, so the LLM sees the fresh data and
+   *    doesn't re-call.
+   *
+   * Throws if the tool isn't registered, isn't read-only, or fails input
+   * validation. Tool execution errors are returned as `{ data, isError: true }`
+   * for the caller to handle (typically: skip the injection so the LLM falls
+   * back to its normal flow).
+   */
+  async invokeReadTool(toolName, input, options = {}) {
+    const tool = findTool(this.tools, toolName);
+    if (!tool) throw new Error(`invokeReadTool: tool not found: ${toolName}`);
+    if (!tool.isReadOnly) {
+      throw new Error(`invokeReadTool: tool is not read-only: ${toolName} (write tools must go through the permission gate)`);
+    }
+    const parsed = tool.inputSchema.safeParse(input);
+    if (!parsed.success) {
+      throw new Error(
+        `invokeReadTool: invalid input for ${toolName}: ${parsed.error.issues.map((i) => i.message).join(", ")}`
+      );
+    }
+    const signal = options.signal ?? new AbortController().signal;
+    const context = {
+      agent: this.agent,
+      mcpManager: this.mcpManager,
+      walletAddress: this.walletAddress,
+      suiRpcUrl: this.suiRpcUrl,
+      serverPositions: this.serverPositions,
+      positionFetcher: this.positionFetcher,
+      env: this.env,
+      signal,
+      priceCache: this.priceCache,
+      permissionConfig: this.permissionConfig,
+      sessionSpendUsd: this.sessionSpendUsd
+    };
+    try {
+      const result = await tool.call(parsed.data, context);
+      return { data: result.data, isError: false };
+    } catch (err) {
+      return {
+        data: { error: err instanceof Error ? err.message : "Tool execution failed" },
+        isError: true
+      };
+    }
+  }
   setServerPositions(data) {
     this.serverPositions = data;
   }