agentlili 0.1.0

package/dist/mcp-server.js

@@ -0,0 +1,1468 @@
+#!/usr/bin/env node
+#!/usr/bin/env node
+import {
+  WalletManager,
+  prisma
+} from "./chunk-AAYS2L5P.js";
+
+// src/mcp/server.ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+  ListPromptsRequestSchema,
+  GetPromptRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+
+// src/lib/audit-log.ts
+import crypto from "crypto";
+function hmacKey() {
+  return process.env.WALLET_ENCRYPTION_KEY ?? "audit-fallback-key";
+}
+function computeHmac(prevHash, data) {
+  return crypto.createHmac("sha256", hmacKey()).update(prevHash + data).digest("hex");
+}
+async function readAuditLog(opts = {}) {
+  const where = {};
+  if (opts.action) where.action = opts.action;
+  if (opts.walletId) where.walletId = opts.walletId;
+  if (opts.agentId) where.agentId = opts.agentId;
+  if (opts.after || opts.before) {
+    const timestampFilter = {};
+    if (opts.after) timestampFilter.gt = new Date(opts.after);
+    if (opts.before) timestampFilter.lt = new Date(opts.before);
+    where.timestamp = timestampFilter;
+  }
+  const rows = await prisma.auditLog.findMany({
+    where,
+    orderBy: { seq: "desc" },
+    skip: opts.offset ?? 0,
+    take: opts.limit ?? 100
+  });
+  return rows.map((row) => ({
+    timestamp: row.timestamp.toISOString(),
+    seq: row.seq,
+    action: row.action,
+    walletId: row.walletId ?? void 0,
+    agentId: row.agentId ?? void 0,
+    ip: row.ip ?? void 0,
+    outcome: row.outcome,
+    details: row.details ?? void 0,
+    integrity: row.integrity
+  }));
+}
+async function verifyAuditIntegrity() {
+  const rows = await prisma.auditLog.findMany({
+    orderBy: { seq: "asc" }
+  });
+  if (rows.length === 0) return { valid: true, total: 0 };
+  let prevHash = "genesis";
+  for (const row of rows) {
+    const entry = {
+      timestamp: row.timestamp.toISOString(),
+      seq: row.seq,
+      action: row.action,
+      walletId: row.walletId ?? void 0,
+      agentId: row.agentId ?? void 0,
+      ip: row.ip ?? void 0,
+      outcome: row.outcome,
+      details: row.details ?? void 0
+    };
+    const rawForHmac = {
+      timestamp: entry.timestamp,
+      action: entry.action,
+      outcome: entry.outcome,
+      seq: entry.seq
+    };
+    if (entry.walletId !== void 0) rawForHmac.walletId = entry.walletId;
+    if (entry.agentId !== void 0) rawForHmac.agentId = entry.agentId;
+    if (entry.ip !== void 0) rawForHmac.ip = entry.ip;
+    if (entry.details !== void 0) rawForHmac.details = entry.details;
+    const entryData = JSON.stringify(rawForHmac);
+    const expected = computeHmac(prevHash, entryData);
+    if (expected !== row.integrity) {
+      return { valid: false, total: rows.length, brokenAt: row.seq };
+    }
+    prevHash = row.integrity;
+  }
+  return { valid: true, total: rows.length };
+}
+
+// src/lib/spending-limits.ts
+var DEFAULT_LIMITS = {
+  maxPerTx: 1,
+  maxPerDay: 5,
+  enabled: true
+};
+var DAY_MS = 24 * 60 * 60 * 1e3;
+async function getSpendingLimits(walletId) {
+  const row = await prisma.spendingLimits.findUnique({
+    where: { walletId }
+  });
+  if (!row) {
+    return { ...DEFAULT_LIMITS };
+  }
+  return {
+    maxPerTx: row.maxPerTx,
+    maxPerDay: row.maxPerDay,
+    enabled: row.enabled
+  };
+}
+async function setSpendingLimits(walletId, config) {
+  const current = await getSpendingLimits(walletId);
+  const updated = {
+    maxPerTx: typeof config.maxPerTx === "number" ? Math.max(0, config.maxPerTx) : current.maxPerTx,
+    maxPerDay: typeof config.maxPerDay === "number" ? Math.max(0, config.maxPerDay) : current.maxPerDay,
+    enabled: typeof config.enabled === "boolean" ? config.enabled : current.enabled
+  };
+  await prisma.spendingLimits.upsert({
+    where: { walletId },
+    create: {
+      walletId,
+      maxPerTx: updated.maxPerTx,
+      maxPerDay: updated.maxPerDay,
+      enabled: updated.enabled
+    },
+    update: {
+      maxPerTx: updated.maxPerTx,
+      maxPerDay: updated.maxPerDay,
+      enabled: updated.enabled
+    }
+  });
+  return updated;
+}
+async function getDailySpending(walletId) {
+  const cutoff = new Date(Date.now() - DAY_MS);
+  const result = await prisma.spendingRecord.aggregate({
+    where: {
+      walletId,
+      timestamp: { gte: cutoff }
+    },
+    _sum: { amount: true }
+  });
+  const total = result._sum.amount ?? 0;
+  return Math.round(total * 1e9) / 1e9;
+}
+async function getSpendingSummary(walletId) {
+  const limits = await getSpendingLimits(walletId);
+  const dailySpent = await getDailySpending(walletId);
+  const dailyRemaining = limits.enabled && limits.maxPerDay > 0 ? Math.max(0, limits.maxPerDay - dailySpent) : null;
+  return { limits, dailySpent, dailyRemaining };
+}
+
+// src/lib/agent-lifecycle.ts
+var VALID_LIFECYCLE_STATES = [
+  "active",
+  "paused",
+  "terminated"
+];
+var MAX_TRANSITIONS = 10;
+var VALID_TRANSITIONS = {
+  active: ["paused", "terminated"],
+  paused: ["active", "terminated"],
+  terminated: []
+};
+async function getAgentLifecycle(walletId) {
+  const row = await prisma.agentLifecycle.findUnique({
+    where: { walletId }
+  });
+  if (!row) {
+    return {
+      state: "active",
+      updatedAt: "",
+      transitions: []
+    };
+  }
+  const state = VALID_LIFECYCLE_STATES.includes(row.state) ? row.state : "active";
+  return {
+    state,
+    updatedAt: row.updatedAt.toISOString(),
+    reason: row.reason ?? void 0,
+    transitions: row.transitions ?? []
+  };
+}
+function validateTransition(from, to) {
+  if (from === to) {
+    return `Agent is already in "${to}" state`;
+  }
+  const allowed = VALID_TRANSITIONS[from];
+  if (!allowed.includes(to)) {
+    return `Cannot transition from "${from}" to "${to}". Terminated agents cannot be restarted.`;
+  }
+  return null;
+}
+async function setAgentLifecycle(walletId, newState, reason) {
+  if (!VALID_LIFECYCLE_STATES.includes(newState)) {
+    throw new Error(
+      `Invalid lifecycle state: ${newState}. Must be one of: ${VALID_LIFECYCLE_STATES.join(", ")}`
+    );
+  }
+  const current = await getAgentLifecycle(walletId);
+  const error = validateTransition(current.state, newState);
+  if (error) {
+    throw new Error(error);
+  }
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const transition = {
+    from: current.state,
+    to: newState,
+    timestamp: now,
+    reason
+  };
+  const transitions = [...current.transitions, transition].slice(
+    -MAX_TRANSITIONS
+  );
+  await prisma.agentLifecycle.upsert({
+    where: { walletId },
+    update: {
+      state: newState,
+      reason: reason ?? null,
+      transitions
+    },
+    create: {
+      walletId,
+      state: newState,
+      reason: reason ?? null,
+      transitions
+    }
+  });
+  return {
+    state: newState,
+    updatedAt: now,
+    reason,
+    transitions
+  };
+}
+async function isAgentExecutable(walletId) {
+  const lifecycle = await getAgentLifecycle(walletId);
+  if (lifecycle.state === "active") {
+    return { allowed: true, state: "active" };
+  }
+  const reason = lifecycle.state === "paused" ? "Agent is paused. Resume it to continue execution." : "Agent is terminated. Create a new agent to continue.";
+  return { allowed: false, state: lifecycle.state, reason };
+}
+
+// src/lib/tx-log.ts
+async function readTxLog(walletId, limit = 50) {
+  const rows = await prisma.txLog.findMany({
+    where: { walletId },
+    orderBy: { timestamp: "desc" },
+    take: limit
+  });
+  return rows.map((row) => ({
+    timestamp: row.timestamp.toISOString(),
+    walletId: row.walletId,
+    toolName: row.toolName,
+    args: row.args,
+    result: row.result,
+    success: row.success
+  }));
+}
+
+// src/lib/agent-strategy.ts
+var STRATEGY_PRESETS = {
+  conservative: {
+    id: "conservative",
+    name: "Conservative",
+    description: "Low risk \u2014 small positions, only well-known protocols, no leverage. Prioritizes capital preservation.",
+    maxPositionSize: 0.1,
+    slippageBps: 100,
+    allowLeverage: false,
+    allowUnverifiedTokens: false,
+    maxOpenPositions: 2,
+    protocolGuidance: "Only use well-established protocols: Jupiter (swaps), Marinade/Jito (liquid staking). Avoid Drift, Adrena, and leveraged products.",
+    promptGuidance: [
+      "You are operating in CONSERVATIVE mode. Capital preservation is your top priority.",
+      "- Maximum position size: 10% of wallet balance per trade",
+      "- Use tight slippage (1% / 100 bps) \u2014 reject trades with higher slippage",
+      "- Only interact with well-known, audited protocols (Jupiter, Orca, Marinade, Jito)",
+      "- Do NOT use leverage, perpetuals, or margin trading",
+      "- Do NOT trade unverified or low-liquidity tokens",
+      "- Maximum 2 open positions at a time",
+      "- Always check balance before and after trades",
+      "- Prefer liquid staking (mSOL, jitoSOL) over risky DeFi yields",
+      "- If unsure about a trade, err on the side of NOT executing it"
+    ].join("\n")
+  },
+  balanced: {
+    id: "balanced",
+    name: "Balanced",
+    description: "Moderate risk \u2014 standard positions, most protocols allowed, moderate slippage tolerance. Good all-around strategy.",
+    maxPositionSize: 0.25,
+    slippageBps: 300,
+    allowLeverage: false,
+    allowUnverifiedTokens: false,
+    maxOpenPositions: 5,
+    protocolGuidance: "Use established protocols freely: Jupiter, Orca, Raydium, Meteora for swaps/LP, Marinade/Jito for staking, Lulo for lending. Avoid leverage protocols.",
+    promptGuidance: [
+      "You are operating in BALANCED mode. Seek reasonable returns while managing risk.",
+      "- Maximum position size: 25% of wallet balance per trade",
+      "- Standard slippage tolerance (3% / 300 bps)",
+      "- Use established protocols: Jupiter, Orca, Raydium, Meteora, Marinade, Jito, Lulo",
+      "- Do NOT use leverage or perpetual trading",
+      "- Only trade tokens with reasonable liquidity",
+      "- Maximum 5 open positions at a time",
+      "- Diversify across different protocols and strategies when possible",
+      "- Provide liquidity on concentrated AMMs only if the range is reasonable",
+      "- Monitor position health and rebalance if needed"
+    ].join("\n")
+  },
+  aggressive: {
+    id: "aggressive",
+    name: "Aggressive",
+    description: "High risk \u2014 large positions, all protocols including leverage, wider slippage. Maximizes upside potential.",
+    maxPositionSize: 0.5,
+    slippageBps: 500,
+    allowLeverage: true,
+    allowUnverifiedTokens: true,
+    maxOpenPositions: 10,
+    protocolGuidance: "All protocols available: Jupiter, Orca, Raydium, Meteora, Drift, Adrena, Lulo, and experimental protocols. Leverage and perps are allowed.",
+    promptGuidance: [
+      "You are operating in AGGRESSIVE mode. Maximize returns \u2014 higher risk is acceptable.",
+      "- Maximum position size: 50% of wallet balance per trade",
+      "- Wide slippage tolerance (5% / 500 bps) for fast execution",
+      "- All protocols available including Drift and Adrena for perpetuals",
+      "- Leverage and margin trading are ALLOWED \u2014 use up to 3x leverage max",
+      "- New and trending tokens are allowed if requested",
+      "- Maximum 10 open positions at a time",
+      "- Actively seek yield farming and liquidity provision opportunities",
+      "- Execute multi-step DeFi strategies: swap \u2192 LP \u2192 stake for compound yields",
+      "- Act decisively \u2014 speed of execution matters"
+    ].join("\n")
+  }
+};
+var VALID_STRATEGY_IDS = [
+  "conservative",
+  "balanced",
+  "aggressive"
+];
+var DEFAULT_STRATEGY_ID = "balanced";
+async function getWalletStrategy(walletId) {
+  const row = await prisma.agentStrategyConfig.findUnique({
+    where: { walletId }
+  });
+  if (!row) {
+    return { strategyId: DEFAULT_STRATEGY_ID, updatedAt: "" };
+  }
+  const id = VALID_STRATEGY_IDS.includes(row.strategyId) ? row.strategyId : DEFAULT_STRATEGY_ID;
+  return {
+    strategyId: id,
+    updatedAt: row.updatedAt.toISOString()
+  };
+}
+
+// src/lib/agent-monitor.ts
+var EXECUTING_THRESHOLD_MS = 3e4;
+function deriveStatus(lastAction) {
+  if (!lastAction) return "idle";
+  const elapsed = Date.now() - new Date(lastAction.timestamp).getTime();
+  if (elapsed < EXECUTING_THRESHOLD_MS) {
+    return lastAction.success ? "executing" : "error";
+  }
+  if (!lastAction.success) return "error";
+  return "idle";
+}
+function extractLastAction(entries) {
+  if (entries.length === 0) return null;
+  const latest = entries[0];
+  return {
+    toolName: latest.toolName,
+    success: latest.success,
+    timestamp: latest.timestamp
+  };
+}
+function calcSuccessRate(entries) {
+  if (entries.length === 0) return 1;
+  const successes = entries.filter((e) => e.success).length;
+  return successes / entries.length;
+}
+async function buildAgentEntry(wallet, balance, txEntries) {
+  const lastAction = extractLastAction(txEntries);
+  const lifecycle = await getAgentLifecycle(wallet.id);
+  const status = lifecycle.state === "paused" ? "paused" : lifecycle.state === "terminated" ? "terminated" : deriveStatus(lastAction);
+  const strategy = await getWalletStrategy(wallet.id);
+  const spending = await getSpendingSummary(wallet.id);
+  return {
+    id: wallet.id,
+    publicKey: wallet.publicKey,
+    label: wallet.label || `Agent ${wallet.id}`,
+    createdAt: wallet.createdAt,
+    balance,
+    status,
+    lifecycleState: lifecycle.state,
+    strategy: strategy.strategyId,
+    lastAction,
+    spending: {
+      dailySpent: spending.dailySpent,
+      dailyLimit: spending.limits.maxPerDay,
+      dailyRemaining: spending.dailyRemaining,
+      enabled: spending.limits.enabled
+    },
+    totalActions: txEntries.length,
+    successRate: calcSuccessRate(txEntries)
+  };
+}
+async function buildAgentMonitor(manager) {
+  const allWallets = await manager.listWallets();
+  const wallets = allWallets.filter((w) => w.isAgent !== false);
+  const entries = await Promise.all(
+    wallets.map(async (wallet) => {
+      let balance = 0;
+      try {
+        balance = await manager.getBalance(wallet.publicKey);
+      } catch {
+      }
+      const txEntries = await readTxLog(wallet.id, 50);
+      return buildAgentEntry(wallet, balance, txEntries);
+    })
+  );
+  const statusOrder = {
+    executing: 0,
+    error: 1,
+    idle: 2,
+    paused: 3,
+    terminated: 4
+  };
+  entries.sort((a, b) => {
+    const statusDiff = statusOrder[a.status] - statusOrder[b.status];
+    if (statusDiff !== 0) return statusDiff;
+    return new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime();
+  });
+  return {
+    agents: entries,
+    totalAgents: entries.length,
+    activeAgents: entries.filter((e) => e.status === "executing").length,
+    errorAgents: entries.filter((e) => e.status === "error").length,
+    pausedAgents: entries.filter((e) => e.status === "paused").length,
+    terminatedAgents: entries.filter((e) => e.status === "terminated").length,
+    fetchedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+
+// src/lib/portfolio.ts
+var SOL_MINT = "So11111111111111111111111111111111111111112";
+var JUPITER_PRICE_URL = "https://api.jup.ag/price/v2";
+var PRICE_TIMEOUT_MS = 8e3;
+var KNOWN_TOKENS = {
+  [SOL_MINT]: "SOL",
+  EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v: "USDC",
+  Es9vMFrzaCERmJfrF4H2FYD4KCoNkY11McCe8BenwNYB: "USDT",
+  mSoLzYCxHdYgdzU16g5QSh3i5K3z3KZK7ytfqcJm7So: "mSOL",
+  "7dHbWXmci3dT8UFYWYZweBLXgycu7Y3iL6trKn1Y7ARj": "stSOL",
+  DezXAZ8z7PnrnRJjz3wXBoRgixCa6xjnB7YaB1pPB263: "BONK",
+  JUPyiwrYJFskUPiHa7hkeR8VUtAeFoSYbKedZNsDvCN: "JUP"
+};
+function resolveSymbol(mint) {
+  return KNOWN_TOKENS[mint] ?? `${mint.slice(0, 4)}\u2026${mint.slice(-4)}`;
+}
+var ALLOC_COLORS = [
+  "#22c55e",
+  "#3b82f6",
+  "#f59e0b",
+  "#ef4444",
+  "#8b5cf6",
+  "#ec4899",
+  "#06b6d4",
+  "#f97316",
+  "#14b8a6",
+  "#6366f1"
+];
+async function fetchPrices(mints) {
+  const prices = /* @__PURE__ */ new Map();
+  if (mints.length === 0) return prices;
+  try {
+    const ids = mints.join(",");
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), PRICE_TIMEOUT_MS);
+    const res = await fetch(`${JUPITER_PRICE_URL}?ids=${ids}`, {
+      signal: controller.signal
+    });
+    clearTimeout(timer);
+    if (!res.ok) return prices;
+    const json = await res.json();
+    for (const [mint, info] of Object.entries(json.data ?? {})) {
+      if (info.price) {
+        const p = parseFloat(info.price);
+        if (Number.isFinite(p) && p > 0) prices.set(mint, p);
+      }
+    }
+  } catch {
+  }
+  return prices;
+}
+async function buildPortfolio(manager) {
+  const wallets = await manager.listWallets();
+  const walletData = await Promise.all(
+    wallets.map(async (w) => {
+      const [solBalance, tokens] = await Promise.all([
+        manager.getBalance(w.publicKey).catch(() => 0),
+        manager.getTokenBalances(w.publicKey).catch(() => [])
+      ]);
+      return { wallet: w, solBalance, tokens };
+    })
+  );
+  const allMints = /* @__PURE__ */ new Set([SOL_MINT]);
+  for (const { tokens } of walletData) {
+    for (const t of tokens) allMints.add(t.mint);
+  }
+  const prices = await fetchPrices([...allMints]);
+  const solPrice = prices.get(SOL_MINT) ?? null;
+  const walletHoldings = walletData.map(
+    ({ wallet, solBalance, tokens }) => {
+      const solValueUsd = solPrice !== null ? solBalance * solPrice : null;
+      const tokenHoldings = tokens.map((t) => {
+        const priceUsd = prices.get(t.mint) ?? null;
+        const valueUsd = priceUsd !== null ? t.balance * priceUsd : null;
+        return {
+          mint: t.mint,
+          symbol: resolveSymbol(t.mint),
+          balance: t.balance,
+          decimals: t.decimals,
+          priceUsd,
+          valueUsd
+        };
+      });
+      const tokenValueSum = tokenHoldings.reduce(
+        (s, t) => s + (t.valueUsd ?? 0),
+        0
+      );
+      const totalValueUsd2 = solValueUsd !== null ? solValueUsd + tokenValueSum : null;
+      return {
+        walletId: wallet.id,
+        publicKey: wallet.publicKey,
+        label: wallet.label || `Agent ${wallet.id.slice(0, 6)}`,
+        solBalance,
+        solValueUsd,
+        tokens: tokenHoldings,
+        totalValueUsd: totalValueUsd2
+      };
+    }
+  );
+  const allocMap = /* @__PURE__ */ new Map();
+  const totalSolValue = walletHoldings.reduce(
+    (s, w) => s + (w.solValueUsd ?? 0),
+    0
+  );
+  if (totalSolValue > 0) {
+    allocMap.set(SOL_MINT, { label: "SOL", valueUsd: totalSolValue });
+  }
+  for (const wh of walletHoldings) {
+    for (const t of wh.tokens) {
+      if (t.valueUsd && t.valueUsd > 0) {
+        const ex = allocMap.get(t.mint);
+        if (ex) ex.valueUsd += t.valueUsd;
+        else allocMap.set(t.mint, { label: t.symbol, valueUsd: t.valueUsd });
+      }
+    }
+  }
+  const totalValueUsd = walletHoldings.reduce(
+    (s, w) => s + (w.totalValueUsd ?? 0),
+    0
+  );
+  const sortedAlloc = [...allocMap.entries()].sort(
+    (a, b) => b[1].valueUsd - a[1].valueUsd
+  );
+  const allocation = sortedAlloc.map(
+    ([mint, { label, valueUsd }], i) => ({
+      label,
+      mint,
+      valueUsd,
+      percentage: totalValueUsd > 0 ? valueUsd / totalValueUsd * 100 : 0,
+      color: ALLOC_COLORS[i % ALLOC_COLORS.length]
+    })
+  );
+  return {
+    totalValueUsd: solPrice !== null ? totalValueUsd : null,
+    solPrice,
+    walletCount: wallets.length,
+    wallets: walletHoldings,
+    allocation,
+    fetchedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+
+// src/lib/fraud-monitor.ts
+import crypto3 from "crypto";
+
+// src/lib/notifications.ts
+import crypto2 from "crypto";
+
+// src/lib/event-bus.ts
+var encoder = new TextEncoder();
+var nextEventId = 1;
+var EventBus = class {
+  constructor() {
+    this.clients = /* @__PURE__ */ new Map();
+    this.listeners = [];
+  }
+  /** Register a non-SSE listener. Returns a cleanup function. */
+  addListener(fn) {
+    this.listeners.push(fn);
+    return () => {
+      this.listeners = this.listeners.filter((l) => l !== fn);
+    };
+  }
+  /** Register a new SSE client. Returns a cleanup function. */
+  addClient(client) {
+    this.clients.set(client.id, client);
+    return () => {
+      this.clients.delete(client.id);
+    };
+  }
+  /** Get count of connected clients. */
+  get clientCount() {
+    return this.clients.size;
+  }
+  /** Emit a typed event to all matching clients. Returns the full event. */
+  emit(partial) {
+    const event = {
+      ...partial,
+      id: String(nextEventId++),
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    const encoded = encoder.encode(`data: ${JSON.stringify(event)}
+
+`);
+    for (const [clientId, client] of this.clients) {
+      if (client.walletId && event.walletId && client.walletId !== event.walletId) {
+        continue;
+      }
+      try {
+        client.controller.enqueue(encoded);
+      } catch {
+        this.clients.delete(clientId);
+      }
+    }
+    for (const listener of this.listeners) {
+      try {
+        listener(event);
+      } catch {
+      }
+    }
+    return event;
+  }
+  /** Send a keep-alive comment to all connected clients. */
+  ping() {
+    const encoded = encoder.encode(`: ping
+
+`);
+    for (const [clientId, client] of this.clients) {
+      try {
+        client.controller.enqueue(encoded);
+      } catch {
+        this.clients.delete(clientId);
+      }
+    }
+  }
+  /** Remove all clients and listeners — only for tests. */
+  _reset() {
+    this.clients.clear();
+    this.listeners = [];
+    nextEventId = 1;
+  }
+};
+var GLOBAL_KEY = "__agent_event_bus__";
+function getEventBus() {
+  const g = globalThis;
+  if (!g[GLOBAL_KEY]) {
+    g[GLOBAL_KEY] = new EventBus();
+  }
+  return g[GLOBAL_KEY];
+}
+var eventBus = getEventBus();
+
+// src/lib/fraud-monitor.ts
+async function getAlerts(walletId, opts) {
+  const where = { walletId };
+  if (opts?.unacknowledgedOnly) {
+    where.acknowledged = false;
+  }
+  const rows = await prisma.fraudAlert.findMany({
+    where,
+    orderBy: { timestamp: "desc" }
+  });
+  return rows.map((row) => ({
+    id: row.id,
+    walletId: row.walletId,
+    rule: row.rule,
+    severity: row.severity,
+    timestamp: row.timestamp.toISOString(),
+    details: row.details,
+    acknowledged: row.acknowledged
+  }));
+}
+async function getFraudStats(walletId) {
+  const alerts = await getAlerts(walletId);
+  const bySeverity = {};
+  const byRule = {};
+  let unacknowledged = 0;
+  for (const a of alerts) {
+    bySeverity[a.severity] = (bySeverity[a.severity] ?? 0) + 1;
+    byRule[a.rule] = (byRule[a.rule] ?? 0) + 1;
+    if (!a.acknowledged) unacknowledged++;
+  }
+  return {
+    totalAlerts: alerts.length,
+    unacknowledged,
+    bySeverity,
+    byRule
+  };
+}
+
+// src/mcp/tools.ts
+var _manager = null;
+function getManager(ctx) {
+  if (!_manager) {
+    _manager = new WalletManager(ctx.encryptionKey, ctx.rpcUrl);
+  }
+  return _manager;
+}
+var TOOLS = [
+  // ── Wallet Operations ──
+  {
+    name: "stng_wallet_create",
+    description: "Create a new Solana wallet with AES-256-GCM encryption. On devnet, automatically airdrops 1 SOL. Returns wallet ID, public key, and balance.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        label: {
+          type: "string",
+          description: "Human-readable label for the wallet (e.g., 'trading-bot-1')"
+        }
+      },
+      required: []
+    }
+  },
+  {
+    name: "stng_wallet_list",
+    description: "List all wallets managed by this instance. Returns wallet IDs, public keys, labels, and creation dates.",
+    inputSchema: {
+      type: "object",
+      properties: {},
+      required: []
+    }
+  },
+  {
+    name: "stng_wallet_balance",
+    description: "Get the SOL balance of a wallet by its public key (base58). Returns balance in SOL.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        public_key: {
+          type: "string",
+          description: "Solana public key (base58 encoded)"
+        }
+      },
+      required: ["public_key"]
+    }
+  },
+  {
+    name: "stng_wallet_tokens",
+    description: "Get all SPL token balances for a wallet. Returns mint addresses, balances, and decimals.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        public_key: {
+          type: "string",
+          description: "Solana public key (base58 encoded)"
+        }
+      },
+      required: ["public_key"]
+    }
+  },
+  {
+    name: "stng_wallet_airdrop",
+    description: "Request a devnet SOL airdrop to a wallet. Only works on devnet/localnet. Default: 1 SOL.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        public_key: {
+          type: "string",
+          description: "Solana public key (base58 encoded)"
+        },
+        amount: {
+          type: "number",
+          description: "Amount of SOL to airdrop (default: 1)"
+        }
+      },
+      required: ["public_key"]
+    }
+  },
+  // ── FROST Threshold Signing ──
+  {
+    name: "stng_frost_create",
+    description: "Create a FROST 2-of-3 threshold signing wallet. Uses Shamir secret sharing (RFC 9591) so no single party holds the full key. Returns wallet ID and group public key.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        label: {
+          type: "string",
+          description: "Label for the FROST wallet"
+        },
+        threshold: {
+          type: "number",
+          description: "Signing threshold (default: 2)"
+        },
+        total_shares: {
+          type: "number",
+          description: "Total key shares (default: 3)"
+        }
+      },
+      required: []
+    }
+  },
+  {
+    name: "stng_frost_list",
+    description: "List all FROST threshold wallets with their group public keys, thresholds, and share counts.",
+    inputSchema: {
+      type: "object",
+      properties: {},
+      required: []
+    }
+  },
+  {
+    name: "stng_frost_verify",
+    description: "Verify the integrity of a FROST wallet's key shares. Confirms shares can reconstruct a valid group signature.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        wallet_id: {
+          type: "string",
+          description: "FROST wallet ID (8-char hex)"
+        }
+      },
+      required: ["wallet_id"]
+    }
+  },
+  // ── Agent Lifecycle ──
+  {
+    name: "stng_agent_status",
+    description: "Get the lifecycle state (active/paused/terminated) of an agent wallet, including transition history and execution eligibility.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        wallet_id: {
+          type: "string",
+          description: "Agent wallet ID (8-char hex)"
+        }
+      },
+      required: ["wallet_id"]
+    }
+  },
+  {
+    name: "stng_agent_pause",
+    description: "Pause an active agent. Paused agents cannot execute transactions but retain their wallets and state.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        wallet_id: {
+          type: "string",
+          description: "Agent wallet ID to pause"
+        },
+        reason: {
+          type: "string",
+          description: "Reason for pausing (logged in audit trail)"
+        }
+      },
+      required: ["wallet_id"]
+    }
+  },
+  {
+    name: "stng_agent_resume",
+    description: "Resume a paused agent, restoring its ability to execute transactions.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        wallet_id: {
+          type: "string",
+          description: "Agent wallet ID to resume"
+        },
+        reason: {
+          type: "string",
+          description: "Reason for resuming (logged in audit trail)"
+        }
+      },
+      required: ["wallet_id"]
+    }
+  },
+  {
+    name: "stng_agent_monitor",
+    description: "Get fleet-wide agent monitoring dashboard. Shows all agents with balances, statuses, strategies, success rates, and spending summaries.",
+    inputSchema: {
+      type: "object",
+      properties: {},
+      required: []
+    }
+  },
+  // ── Spending & Security ──
+  {
+    name: "stng_spending_limits",
+    description: "Get or update spending limits for a wallet. Returns per-transaction limit, daily limit, and current usage.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        wallet_id: {
+          type: "string",
+          description: "Wallet ID (8-char hex)"
+        },
+        action: {
+          type: "string",
+          enum: ["get", "set"],
+          description: "Whether to get current limits or set new ones (default: get)"
+        },
+        per_tx_limit: {
+          type: "number",
+          description: "Max SOL per transaction (only for action=set)"
+        },
+        daily_limit: {
+          type: "number",
+          description: "Max SOL per 24h (only for action=set)"
+        }
+      },
+      required: ["wallet_id"]
+    }
+  },
+  {
+    name: "stng_audit_log",
+    description: "Read the HMAC-chained audit log. Filter by action type, wallet ID, agent ID, or time range. Returns tamper-evident entries newest-first.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        action: {
+          type: "string",
+          description: "Filter by action type (e.g., 'wallet_create', 'frost_sign', 'agent_tool_call')"
+        },
+        wallet_id: {
+          type: "string",
+          description: "Filter by wallet ID"
+        },
+        limit: {
+          type: "number",
+          description: "Max entries to return (default: 20)"
+        }
+      },
+      required: []
+    }
+  },
+  {
+    name: "stng_audit_verify",
+    description: "Verify the integrity of the entire HMAC-chained audit log. Detects any tampering or corruption in the chain.",
+    inputSchema: {
+      type: "object",
+      properties: {},
+      required: []
+    }
+  },
+  // ── Portfolio & Analytics ──
+  {
+    name: "stng_portfolio",
+    description: "Get a portfolio summary across all wallets. Includes SOL and token balances, USD values (via Jupiter Price API), and allocation breakdown.",
+    inputSchema: {
+      type: "object",
+      properties: {},
+      required: []
+    }
+  },
+  {
+    name: "stng_tx_history",
+    description: "Get recent transaction history for a wallet. Shows tool calls, results, and success/failure status.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        wallet_id: {
+          type: "string",
+          description: "Wallet ID (8-char hex)"
+        },
+        limit: {
+          type: "number",
+          description: "Max entries (default: 20)"
+        }
+      },
+      required: ["wallet_id"]
+    }
+  },
+  {
+    name: "stng_fraud_alerts",
+    description: "Get fraud detection alerts for a wallet. Monitors for rapid drain, velocity spikes, new program interaction, authority changes, and repeated failures.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        wallet_id: {
+          type: "string",
+          description: "Wallet ID (8-char hex)"
+        }
+      },
+      required: ["wallet_id"]
+    }
+  }
+];
+async function handleTool(name, args, ctx) {
+  const manager = getManager(ctx);
+  switch (name) {
+    // ── Wallet Operations ──
+    case "stng_wallet_create": {
+      const label = args.label;
+      const wallet = await manager.createWalletWithAirdrop(label, 1, {
+        isAgent: true
+      });
+      return {
+        wallet_id: wallet.wallet.id,
+        public_key: wallet.wallet.publicKey,
+        label: wallet.wallet.label,
+        created_at: wallet.wallet.createdAt,
+        airdrop: wallet.airdrop ? { signature: wallet.airdrop.signature, amount: wallet.airdrop.amount } : null
+      };
+    }
+    case "stng_wallet_list": {
+      const wallets = await manager.listWallets();
+      return {
+        count: wallets.length,
+        wallets: wallets.map((w) => ({
+          id: w.id,
+          public_key: w.publicKey,
+          label: w.label ?? null,
+          created_at: w.createdAt,
+          is_agent: w.isAgent ?? false
+        }))
+      };
+    }
+    case "stng_wallet_balance": {
+      const pk = args.public_key;
+      const balance = await manager.getBalance(pk);
+      return { public_key: pk, balance_sol: balance };
+    }
+    case "stng_wallet_tokens": {
+      const pk = args.public_key;
+      const tokens = await manager.getTokenBalances(pk);
+      return { public_key: pk, tokens };
+    }
+    case "stng_wallet_airdrop": {
+      const pk = args.public_key;
+      const amount = args.amount ?? 1;
+      const sig = await manager.requestAirdrop(pk, amount);
+      return { public_key: pk, amount, signature: sig };
+    }
+    // ── FROST Threshold Signing ──
+    case "stng_frost_create": {
+      const label = args.label;
+      const threshold = args.threshold ?? 2;
+      const totalShares = args.total_shares ?? 3;
+      const wallet = await manager.createFrostWallet({
+        threshold,
+        totalShares,
+        label
+      });
+      return {
+        wallet_id: wallet.id,
+        group_public_key: wallet.groupPublicKey,
+        threshold: wallet.threshold,
+        total_shares: wallet.totalShares,
+        label: wallet.label ?? null,
+        created_at: wallet.createdAt
+      };
+    }
+    case "stng_frost_list": {
+      const wallets = await manager.listFrostWallets();
+      return {
+        count: wallets.length,
+        wallets: wallets.map((w) => ({
+          id: w.id,
+          group_public_key: w.groupPublicKey,
+          threshold: w.threshold,
+          total_shares: w.totalShares,
+          label: w.label ?? null,
+          created_at: w.createdAt
+        }))
+      };
+    }
+    case "stng_frost_verify": {
+      const walletId = args.wallet_id;
+      const valid = await manager.verifyFrostShares(walletId);
+      return {
+        wallet_id: walletId,
+        shares_valid: valid,
+        message: valid ? "All key shares are intact and can reconstruct a valid group signature." : "Share verification failed \u2014 shares may be corrupted."
+      };
+    }
+    // ── Agent Lifecycle ──
+    case "stng_agent_status": {
+      const walletId = args.wallet_id;
+      const lifecycle = await getAgentLifecycle(walletId);
+      const executable = await isAgentExecutable(walletId);
+      return {
+        wallet_id: walletId,
+        state: lifecycle.state,
+        updated_at: lifecycle.updatedAt,
+        can_execute: executable.allowed,
+        reason: lifecycle.reason ?? null,
+        transitions: lifecycle.transitions
+      };
+    }
+    case "stng_agent_pause": {
+      const walletId = args.wallet_id;
+      const reason = args.reason;
+      const result = await setAgentLifecycle(walletId, "paused", reason);
+      return {
+        wallet_id: walletId,
+        state: result.state,
+        updated_at: result.updatedAt,
+        reason: result.reason ?? null
+      };
+    }
+    case "stng_agent_resume": {
+      const walletId = args.wallet_id;
+      const reason = args.reason;
+      const result = await setAgentLifecycle(walletId, "active", reason);
+      return {
+        wallet_id: walletId,
+        state: result.state,
+        updated_at: result.updatedAt,
+        reason: result.reason ?? null
+      };
+    }
+    case "stng_agent_monitor": {
+      const data = await buildAgentMonitor(manager);
+      return {
+        total_agents: data.totalAgents,
+        active: data.activeAgents,
+        paused: data.pausedAgents,
+        terminated: data.terminatedAgents,
+        error: data.errorAgents,
+        agents: data.agents.map((a) => ({
+          id: a.id,
+          public_key: a.publicKey,
+          label: a.label,
+          balance_sol: a.balance,
+          status: a.status,
+          lifecycle_state: a.lifecycleState,
+          strategy: a.strategy,
+          total_actions: a.totalActions,
+          success_rate: a.successRate,
+          last_action: a.lastAction
+        })),
+        fetched_at: data.fetchedAt
+      };
+    }
+    // ── Spending & Security ──
+    case "stng_spending_limits": {
+      const walletId = args.wallet_id;
+      const action = args.action ?? "get";
+      if (action === "set") {
+        const config = {};
+        if (args.per_tx_limit !== void 0)
+          config.maxPerTx = args.per_tx_limit;
+        if (args.daily_limit !== void 0)
+          config.maxPerDay = args.daily_limit;
+        await setSpendingLimits(walletId, config);
+      }
+      const limits = await getSpendingLimits(walletId);
+      const summary = await getSpendingSummary(walletId);
+      return {
+        wallet_id: walletId,
+        limits,
+        summary
+      };
+    }
+    case "stng_audit_log": {
+      const opts = {
+        limit: args.limit ?? 20
+      };
+      if (args.action) opts.action = args.action;
+      if (args.wallet_id) opts.walletId = args.wallet_id;
+      const entries = await readAuditLog(opts);
+      return { count: entries.length, entries };
+    }
+    case "stng_audit_verify": {
+      const result = await verifyAuditIntegrity();
+      return {
+        ...result,
+        message: result.valid ? `Audit log integrity verified \u2014 ${result.total} entries, chain intact.` : `Audit log integrity BROKEN at entry ${result.brokenAt} of ${result.total}.`
+      };
+    }
+    // ── Portfolio & Analytics ──
+    case "stng_portfolio": {
+      const portfolio = await buildPortfolio(manager);
+      return portfolio;
+    }
+    case "stng_tx_history": {
+      const walletId = args.wallet_id;
+      const limit = args.limit ?? 20;
+      const entries = await readTxLog(walletId, limit);
+      return { wallet_id: walletId, count: entries.length, transactions: entries };
+    }
+    case "stng_fraud_alerts": {
+      const walletId = args.wallet_id;
+      const alerts = await getAlerts(walletId);
+      const stats = await getFraudStats(walletId);
+      return {
+        wallet_id: walletId,
+        alerts,
+        stats
+      };
+    }
+    default:
+      throw new Error(`Unknown tool: ${name}`);
+  }
+}
+
+// src/mcp/prompts.ts
+var PROMPTS = [
+  {
+    name: "portfolio_overview",
+    description: "Get a comprehensive portfolio overview across all wallets with USD values, allocations, and balances.",
+    arguments: []
+  },
+  {
+    name: "security_audit",
+    description: "Run a full security audit: verify audit log integrity, check spending limits, review fraud alerts, and FROST wallet status.",
+    arguments: [
+      {
+        name: "wallet_id",
+        description: "Specific wallet to audit (optional \u2014 omit for fleet-wide)",
+        required: false
+      }
+    ]
+  },
+  {
+    name: "create_agent_wallet",
+    description: "Guided workflow to create a new agent wallet with spending limits and optional FROST threshold protection.",
+    arguments: [
+      {
+        name: "label",
+        description: "Name for the new agent (e.g., 'trading-bot-alpha')",
+        required: true
+      },
+      {
+        name: "use_frost",
+        description: "Whether to create a FROST threshold wallet (yes/no, default: no)",
+        required: false
+      }
+    ]
+  },
+  {
+    name: "fleet_health",
+    description: "Check the health of all agents in the fleet: statuses, balances, success rates, and spending.",
+    arguments: []
+  },
+  {
+    name: "investigate_wallet",
+    description: "Deep investigation of a specific wallet: balance, tokens, transaction history, spending, fraud alerts, and lifecycle state.",
+    arguments: [
+      {
+        name: "wallet_id",
+        description: "The wallet ID to investigate",
+        required: true
+      }
+    ]
+  }
+];
+function getPromptContent(name, args) {
+  switch (name) {
+    case "portfolio_overview":
+      return `Please give me a comprehensive portfolio overview.
+
+Steps:
+1. Use stng_portfolio to get all wallet balances, token holdings, and USD values
+2. Use stng_wallet_list to get wallet labels and metadata
+3. Present a clear summary including:
+   - Total portfolio value in USD
+   - Per-wallet breakdown (label, SOL balance, token balances, USD value)
+   - Asset allocation percentages
+   - Any wallets with zero balance that may need funding`;
+    case "security_audit": {
+      const walletClause = args.wallet_id ? `Focus on wallet ${args.wallet_id}.` : "Audit all wallets fleet-wide.";
+      return `Please run a comprehensive security audit. ${walletClause}
+
+Steps:
+1. Use stng_audit_verify to check HMAC chain integrity of the audit log
+2. Use stng_audit_log to review recent security-relevant events (wallet_create, frost_sign, spending_limit_exceeded)
+3. Use stng_frost_list to check FROST wallet status and verify shares with stng_frost_verify
+4. ${args.wallet_id ? `Use stng_spending_limits for wallet ${args.wallet_id}` : "Use stng_agent_monitor to check all agents"}
+5. ${args.wallet_id ? `Use stng_fraud_alerts for wallet ${args.wallet_id}` : "Check fraud alerts for any flagged wallets"}
+
+Report:
+- Audit log integrity status (intact/broken)
+- Total audit entries and recent activity
+- FROST wallet health
+- Spending limit compliance
+- Any fraud alerts or anomalies
+- Security recommendations`;
+    }
+    case "create_agent_wallet": {
+      const label = args.label || "new-agent";
+      const useFrost = args.use_frost?.toLowerCase() === "yes";
+      return `Please create a new agent wallet named "${label}".
+
+Steps:
+1. ${useFrost ? "Use stng_frost_create to create a FROST 2-of-3 threshold wallet" : "Use stng_wallet_create to create a standard wallet"} with label "${label}"
+2. Use stng_spending_limits with action=set to configure:
+   - per_tx_limit: 0.5 SOL (conservative start)
+   - daily_limit: 2 SOL
+3. Use stng_agent_status to confirm the agent is in "active" state
+4. Use stng_wallet_balance to confirm initial balance
+
+Report the new agent's:
+- Wallet ID
+- Public key
+- ${useFrost ? "FROST group public key and threshold" : "Balance"}
+- Spending limits
+- Lifecycle state`;
+    }
+    case "fleet_health":
+      return `Please check the health of all agents in the fleet.
+
+Steps:
+1. Use stng_agent_monitor to get the full fleet dashboard
+2. For any agents in "error" or "paused" state, use stng_agent_status for details
+3. Use stng_portfolio to check fleet-wide balances
+
+Report:
+- Total agents (active / paused / terminated / error)
+- Per-agent health summary (balance, success rate, last action, strategy)
+- Any agents that need attention (low balance, high failure rate, paused)
+- Fleet-wide statistics (total value, average success rate)`;
+    case "investigate_wallet": {
+      const walletId = args.wallet_id || "[WALLET_ID]";
+      return `Please do a deep investigation of wallet ${walletId}.
+
+Steps:
+1. Use stng_agent_status to check lifecycle state and transition history
+2. Use stng_spending_limits to review spending configuration and usage
+3. Use stng_tx_history to review recent transactions
+4. Use stng_fraud_alerts to check for any security alerts
+5. Use stng_audit_log filtered by wallet_id=${walletId} to review audit trail
+
+Report:
+- Wallet state (active/paused/terminated) and why
+- Spending: limits vs actual usage, any violations
+- Recent transactions: success/failure patterns, tools used
+- Fraud alerts: any triggered rules, severity
+- Audit trail: key events timeline
+- Recommendations for this wallet`;
+    }
+    default:
+      return `Unknown prompt: ${name}`;
+  }
+}
+
+// src/mcp/server.ts
+function createServer(ctx) {
+  const server = new Server(
+    {
+      name: "stng-defi-wallets",
+      version: "0.1.0"
+    },
+    {
+      capabilities: {
+        tools: {},
+        prompts: {}
+      }
+    }
+  );
+  server.setRequestHandler(ListToolsRequestSchema, async () => {
+    return { tools: [...TOOLS] };
+  });
+  server.setRequestHandler(ListPromptsRequestSchema, async () => {
+    return { prompts: PROMPTS };
+  });
+  server.setRequestHandler(GetPromptRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    const prompt = PROMPTS.find((p) => p.name === name);
+    if (!prompt) {
+      throw new Error(`Unknown prompt: ${name}`);
+    }
+    const content = getPromptContent(name, args || {});
+    return {
+      description: prompt.description,
+      messages: [
+        {
+          role: "user",
+          content: {
+            type: "text",
+            text: content
+          }
+        }
+      ]
+    };
+  });
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    try {
+      const result = await handleTool(
+        name,
+        args ?? {},
+        ctx
+      );
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result, null, 2)
+          }
+        ]
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown error";
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({ error: message })
+          }
+        ],
+        isError: true
+      };
+    }
+  });
+  return server;
+}
+async function runMcpServer() {
+  const encryptionKey = process.env.WALLET_ENCRYPTION_KEY;
+  if (!encryptionKey) {
+    throw new Error("WALLET_ENCRYPTION_KEY environment variable is required");
+  }
+  const rpcUrl = process.env.SOLANA_RPC_URL ?? "https://api.devnet.solana.com";
+  const ctx = { encryptionKey, rpcUrl };
+  const server = createServer(ctx);
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error(
+    `stng-defi-wallets MCP server started (${TOOLS.length} tools, ${PROMPTS.length} prompts)`
+  );
+}
+var isDirectRun = process.argv[1]?.endsWith("server.ts") || process.argv[1]?.endsWith("server.js");
+if (isDirectRun) {
+  if (!process.env.WALLET_ENCRYPTION_KEY) {
+    console.error(
+      "Error: WALLET_ENCRYPTION_KEY environment variable is required"
+    );
+    console.error("");
+    console.error("Usage:");
+    console.error(
+      "  WALLET_ENCRYPTION_KEY=<hex-key> npx tsx src/mcp/server.ts"
+    );
+    console.error("");
+    console.error("Environment variables:");
+    console.error(
+      "  WALLET_ENCRYPTION_KEY  (required) 32-byte hex key for wallet encryption"
+    );
+    console.error(
+      "  SOLANA_RPC_URL         (optional) Solana RPC, default: https://api.devnet.solana.com"
+    );
+    console.error("");
+    console.error("Generate a key:");
+    console.error(
+      `  node -e "console.log(require('crypto').randomBytes(32).toString('hex'))"`
+    );
+    process.exit(1);
+  }
+  runMcpServer().catch((error) => {
+    console.error("Fatal error:", error);
+    process.exit(1);
+  });
+}
+export {
+  runMcpServer
+};
+//# sourceMappingURL=mcp-server.js.map