@moly-mcp/lido 1.0.1 → 1.0.2

package/dist/session-55BKKXQV.js

@@ -0,0 +1,494 @@
+#!/usr/bin/env node
+import {
+  castVote,
+  claimWithdrawals,
+  getBalance,
+  getConversionRate,
+  getProposal,
+  getProposals,
+  getRewards,
+  getSettings,
+  getWithdrawalRequests,
+  getWithdrawalStatus,
+  requestWithdrawal,
+  stakeEth,
+  unwrapWsteth,
+  updateSettings,
+  wrapSteth
+} from "./chunk-RE3UIDLV.js";
+import "./chunk-PIFEXJ56.js";
+
+// src/chat/session.ts
+import * as readline from "readline";
+
+// src/chat/providers.ts
+async function callAnthropic(apiKey, model, messages, tools) {
+  const res = await fetch("https://api.anthropic.com/v1/messages", {
+    method: "POST",
+    headers: {
+      "x-api-key": apiKey,
+      "anthropic-version": "2023-06-01",
+      "content-type": "application/json"
+    },
+    body: JSON.stringify({
+      model,
+      max_tokens: 4096,
+      messages,
+      tools: tools.map((t) => ({
+        name: t.name,
+        description: t.description,
+        input_schema: t.parameters
+      }))
+    })
+  });
+  if (!res.ok) {
+    const err = await res.text();
+    throw new Error(`Anthropic API error ${res.status}: ${err}`);
+  }
+  const data = await res.json();
+  const content = data.content;
+  const textBlock = content.find((b) => b.type === "text");
+  const toolUseBlocks = content.filter((b) => b.type === "tool_use");
+  return {
+    text: textBlock?.text ?? null,
+    toolCalls: toolUseBlocks.map((b) => ({
+      id: b.id,
+      name: b.name,
+      args: b.input
+    })),
+    rawAssistantMessage: { role: "assistant", content }
+  };
+}
+function anthropicToolResult(toolCallId, result) {
+  return {
+    role: "user",
+    content: [{ type: "tool_result", tool_use_id: toolCallId, content: result }]
+  };
+}
+async function callOpenRouter(apiKey, model, messages, tools) {
+  const res = await fetch("https://openrouter.ai/api/v1/chat/completions", {
+    method: "POST",
+    headers: {
+      "Authorization": `Bearer ${apiKey}`,
+      "Content-Type": "application/json",
+      "HTTP-Referer": "https://github.com/daiwikmh/moly",
+      "X-Title": "Moly \u2014 Lido MCP"
+    },
+    body: JSON.stringify({
+      model,
+      messages,
+      tools: tools.map((t) => ({
+        type: "function",
+        function: { name: t.name, description: t.description, parameters: t.parameters }
+      }))
+    })
+  });
+  if (!res.ok) {
+    const err = await res.text();
+    throw new Error(`OpenRouter API error ${res.status}: ${err}`);
+  }
+  const data = await res.json();
+  const msg = data.choices[0].message;
+  return {
+    text: msg.content ?? null,
+    toolCalls: (msg.tool_calls ?? []).map((tc) => ({
+      id: tc.id,
+      name: tc.function.name,
+      args: JSON.parse(tc.function.arguments ?? "{}")
+    })),
+    rawAssistantMessage: { role: "assistant", content: msg.content, tool_calls: msg.tool_calls }
+  };
+}
+async function callGemini(apiKey, model, messages, tools) {
+  const contents = messages.map((m) => ({
+    role: m.role === "assistant" ? "model" : "user",
+    parts: Array.isArray(m.content) ? m.content : [{ text: m.content }]
+  }));
+  const res = await fetch(
+    `https://generativelanguage.googleapis.com/v1beta/models/${model}:generateContent?key=${apiKey}`,
+    {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({
+        contents,
+        tools: [{
+          functionDeclarations: tools.map((t) => ({
+            name: t.name,
+            description: t.description,
+            parameters: t.parameters
+          }))
+        }]
+      })
+    }
+  );
+  if (!res.ok) {
+    const err = await res.text();
+    throw new Error(`Gemini API error ${res.status}: ${err}`);
+  }
+  const data = await res.json();
+  const parts = data.candidates?.[0]?.content?.parts ?? [];
+  const textPart = parts.find((p) => p.text);
+  const fnCalls = parts.filter((p) => p.functionCall);
+  return {
+    text: textPart?.text ?? null,
+    toolCalls: fnCalls.map((p, i) => ({
+      id: `gemini-${i}`,
+      name: p.functionCall.name,
+      args: p.functionCall.args ?? {}
+    })),
+    rawAssistantMessage: {
+      role: "model",
+      parts
+    }
+  };
+}
+function geminiToolResult(toolCallId, name, result) {
+  return {
+    role: "user",
+    content: [{ functionResponse: { name, response: { output: result } } }]
+  };
+}
+async function callAi(provider, apiKey, model, messages, tools) {
+  switch (provider) {
+    case "anthropic":
+      return callAnthropic(apiKey, model, messages, tools);
+    case "openrouter":
+      return callOpenRouter(apiKey, model, messages, tools);
+    case "google":
+      return callGemini(apiKey, model, messages, tools);
+    default:
+      throw new Error(`Unsupported provider: ${provider}`);
+  }
+}
+function makeToolResultMessage(provider, toolCallId, toolName, result) {
+  switch (provider) {
+    case "anthropic":
+      return anthropicToolResult(toolCallId, result);
+    case "openrouter":
+      return { role: "tool", content: result, ...{ tool_call_id: toolCallId } };
+    case "google":
+      return geminiToolResult(toolCallId, toolName, result);
+    default:
+      throw new Error(`Unsupported provider: ${provider}`);
+  }
+}
+
+// src/chat/tools.ts
+var TOOL_DEFS = [
+  {
+    name: "get_balance",
+    description: "Get ETH, stETH, and wstETH balances for an address.",
+    parameters: {
+      type: "object",
+      properties: {
+        address: { type: "string", description: "Ethereum address (optional, defaults to configured wallet)" }
+      }
+    }
+  },
+  {
+    name: "get_rewards",
+    description: "Get staking reward history for an address over N days.",
+    parameters: {
+      type: "object",
+      properties: {
+        address: { type: "string", description: "Ethereum address (optional)" },
+        days: { type: "number", description: "Days to look back (1-365), default 7" }
+      }
+    }
+  },
+  {
+    name: "get_conversion_rate",
+    description: "Get current stETH \u2194 wstETH conversion rates.",
+    parameters: { type: "object", properties: {} }
+  },
+  {
+    name: "stake_eth",
+    description: "Stake ETH to receive stETH (liquid staking).",
+    parameters: {
+      type: "object",
+      required: ["amount_eth"],
+      properties: {
+        amount_eth: { type: "string", description: 'Amount of ETH to stake (e.g. "0.1")' },
+        dry_run: { type: "boolean", description: "Simulate without broadcasting" }
+      }
+    }
+  },
+  {
+    name: "request_withdrawal",
+    description: "Request withdrawal of stETH back to ETH. Min 0.1, max 1000 stETH.",
+    parameters: {
+      type: "object",
+      required: ["amount_steth"],
+      properties: {
+        amount_steth: { type: "string", description: "Amount of stETH to withdraw" },
+        dry_run: { type: "boolean" }
+      }
+    }
+  },
+  {
+    name: "claim_withdrawals",
+    description: "Claim finalized withdrawal requests and receive ETH.",
+    parameters: {
+      type: "object",
+      required: ["request_ids"],
+      properties: {
+        request_ids: { type: "array", items: { type: "string" }, description: "Withdrawal request NFT IDs" },
+        dry_run: { type: "boolean" }
+      }
+    }
+  },
+  {
+    name: "get_withdrawal_requests",
+    description: "Get all pending withdrawal request IDs for an address.",
+    parameters: {
+      type: "object",
+      properties: {
+        address: { type: "string", description: "Ethereum address (optional)" }
+      }
+    }
+  },
+  {
+    name: "get_withdrawal_status",
+    description: "Check finalization status of withdrawal request IDs.",
+    parameters: {
+      type: "object",
+      required: ["request_ids"],
+      properties: {
+        request_ids: { type: "array", items: { type: "string" } }
+      }
+    }
+  },
+  {
+    name: "wrap_steth",
+    description: "Wrap stETH into wstETH.",
+    parameters: {
+      type: "object",
+      required: ["amount_steth"],
+      properties: {
+        amount_steth: { type: "string" },
+        dry_run: { type: "boolean" }
+      }
+    }
+  },
+  {
+    name: "unwrap_wsteth",
+    description: "Unwrap wstETH back to stETH.",
+    parameters: {
+      type: "object",
+      required: ["amount_wsteth"],
+      properties: {
+        amount_wsteth: { type: "string" },
+        dry_run: { type: "boolean" }
+      }
+    }
+  },
+  {
+    name: "get_proposals",
+    description: "List recent Lido DAO governance proposals.",
+    parameters: {
+      type: "object",
+      properties: {
+        count: { type: "number", description: "Number of proposals (1-20, default 5)" }
+      }
+    }
+  },
+  {
+    name: "get_proposal",
+    description: "Get detailed info on a specific Lido DAO governance proposal.",
+    parameters: {
+      type: "object",
+      required: ["proposal_id"],
+      properties: {
+        proposal_id: { type: "number" }
+      }
+    }
+  },
+  {
+    name: "cast_vote",
+    description: "Vote YEA or NAY on a Lido DAO governance proposal.",
+    parameters: {
+      type: "object",
+      required: ["proposal_id", "support"],
+      properties: {
+        proposal_id: { type: "number" },
+        support: { type: "boolean", description: "true = YEA, false = NAY" },
+        dry_run: { type: "boolean" }
+      }
+    }
+  },
+  {
+    name: "get_settings",
+    description: "Get current Moly configuration.",
+    parameters: { type: "object", properties: {} }
+  },
+  {
+    name: "update_settings",
+    description: "Change mode, network, or RPC.",
+    parameters: {
+      type: "object",
+      properties: {
+        network: { type: "string", enum: ["hoodi", "mainnet"] },
+        mode: { type: "string", enum: ["simulation", "live"] },
+        rpc: { type: "string", nullable: true },
+        model: { type: "string" }
+      }
+    }
+  }
+];
+async function executeTool(name, args) {
+  try {
+    let result;
+    switch (name) {
+      case "get_balance":
+        result = await getBalance(args.address);
+        break;
+      case "get_rewards":
+        result = await getRewards(args.address, args.days);
+        break;
+      case "get_conversion_rate":
+        result = await getConversionRate();
+        break;
+      case "stake_eth":
+        result = await stakeEth(args.amount_eth, args.dry_run);
+        break;
+      case "request_withdrawal":
+        result = await requestWithdrawal(args.amount_steth, args.dry_run);
+        break;
+      case "claim_withdrawals":
+        result = await claimWithdrawals(args.request_ids, args.dry_run);
+        break;
+      case "get_withdrawal_requests":
+        result = await getWithdrawalRequests(args.address);
+        break;
+      case "get_withdrawal_status":
+        result = await getWithdrawalStatus(args.request_ids);
+        break;
+      case "wrap_steth":
+        result = await wrapSteth(args.amount_steth, args.dry_run);
+        break;
+      case "unwrap_wsteth":
+        result = await unwrapWsteth(args.amount_wsteth, args.dry_run);
+        break;
+      case "get_proposals":
+        result = await getProposals(args.count);
+        break;
+      case "get_proposal":
+        result = await getProposal(args.proposal_id);
+        break;
+      case "cast_vote":
+        result = await castVote(args.proposal_id, args.support, args.dry_run);
+        break;
+      case "get_settings":
+        result = getSettings();
+        break;
+      case "update_settings":
+        result = updateSettings(args);
+        break;
+      default:
+        return `Unknown tool: ${name}`;
+    }
+    return JSON.stringify(result, null, 2);
+  } catch (err) {
+    return `Error: ${err.message}`;
+  }
+}
+
+// src/chat/session.ts
+var RESET = "\x1B[0m";
+var BOLD = "\x1B[1m";
+var DIM = "\x1B[2m";
+var CYAN = "\x1B[36m";
+var GREEN = "\x1B[32m";
+var YELLOW = "\x1B[33m";
+var BLUE = "\x1B[34m";
+var RED = "\x1B[31m";
+function print(text) {
+  process.stdout.write(text + "\n");
+}
+function printBanner(cfg) {
+  const modeColor = cfg.mode === "simulation" ? YELLOW : RED;
+  const modeLabel = cfg.mode === "simulation" ? "\u{1F7E1} SIMULATION" : "\u{1F534} LIVE";
+  print("");
+  print(`${BOLD}${CYAN}  \u2B21  Moly Terminal${RESET} \u2014 Lido on ${cfg.network}`);
+  print(`${DIM}  ${modeColor}${modeLabel}${RESET}${DIM}  \xB7  ${cfg.ai?.model ?? ""}  \xB7  type "exit" to quit${RESET}`);
+  print(`${DIM}${"\u2500".repeat(60)}${RESET}`);
+  print("");
+}
+async function startChatSession(cfg) {
+  if (!cfg.ai) {
+    print(`${RED}No AI provider configured. Run: moly setup${RESET}`);
+    process.exit(1);
+  }
+  const { provider, apiKey, model } = cfg.ai;
+  const messages = [
+    {
+      role: "user",
+      content: `You are Moly, an AI assistant for interacting with Lido Finance on ${cfg.network}. Current mode: ${cfg.mode} (${cfg.mode === "simulation" ? "dry-run, nothing is broadcast" : "LIVE \u2014 real transactions"}). Help the user stake ETH, manage withdrawals, wrap/unwrap tokens, and participate in governance. Always confirm before executing live transactions. Be concise.`
+    },
+    {
+      role: "assistant",
+      content: `Got it. I'm ready to help you interact with Lido on ${cfg.network} in ${cfg.mode} mode. What would you like to do?`
+    }
+  ];
+  printBanner(cfg);
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    terminal: true
+  });
+  const prompt = () => new Promise((resolve) => {
+    rl.question(`${BOLD}${BLUE}you${RESET} \u203A `, resolve);
+  });
+  while (true) {
+    let input;
+    try {
+      input = (await prompt()).trim();
+    } catch {
+      break;
+    }
+    if (!input) continue;
+    if (input.toLowerCase() === "exit" || input.toLowerCase() === "quit") {
+      print(`${DIM}Goodbye.${RESET}`);
+      rl.close();
+      process.exit(0);
+    }
+    messages.push({ role: "user", content: input });
+    try {
+      while (true) {
+        process.stdout.write(`${DIM}thinking...${RESET}\r`);
+        const response = await callAi(provider, apiKey, model, messages, TOOL_DEFS);
+        process.stdout.write(" ".repeat(20) + "\r");
+        messages.push(response.rawAssistantMessage);
+        if (response.toolCalls.length > 0) {
+          const toolResults = [];
+          for (const tc of response.toolCalls) {
+            print(`${DIM}  \u2699  ${tc.name}(${JSON.stringify(tc.args)})${RESET}`);
+            const result = await executeTool(tc.name, tc.args);
+            print(`${DIM}  \u21B3  ${result.slice(0, 200)}${result.length > 200 ? "\u2026" : ""}${RESET}`);
+            toolResults.push(makeToolResultMessage(provider, tc.id, tc.name, result));
+          }
+          messages.push(...toolResults);
+          if (response.text) {
+            print(`
+${BOLD}${GREEN}moly${RESET} \u203A ${response.text}
+`);
+          }
+          continue;
+        }
+        if (response.text) {
+          print(`
+${BOLD}${GREEN}moly${RESET} \u203A ${response.text}
+`);
+        }
+        break;
+      }
+    } catch (err) {
+      print(`${RED}Error: ${err.message}${RESET}`);
+      messages.pop();
+    }
+  }
+  rl.close();
+}
+export {
+  startChatSession
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@moly-mcp/lido",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "description": "Lido MCP Server — stake, unstake, wrap, govern. Works with Claude Desktop, Cursor, Windsurf, and any MCP client.",
   "license": "MIT",
   "type": "module",