@scoutagent/mcp-server 1.0.8 → 1.2.0

package/README.md

@@ -0,0 +1,211 @@
+# @scoutagent/mcp-server
+
+[![npm](https://img.shields.io/npm/v/@scoutagent/mcp-server)](https://www.npmjs.com/package/@scoutagent/mcp-server)
+
+MCP (Model Context Protocol) Server for **ScoutAgent** -- the AI Scout prediction market on X Layer. This server lets any MCP-compatible client (Claude Desktop, Cursor, Windsurf, etc.) interact with ScoutAgent: browse markets, mint Agent NFTs, place bets, view leaderboards, and more.
+
+## Quick Start
+
+```bash
+npx @scoutagent/mcp-server
+```
+
+Or install globally:
+
+```bash
+npm install -g @scoutagent/mcp-server
+scoutagent-mcp
+```
+
+## Configuration
+
+### Environment Variables
+
+| Variable | Default | Description |
+|---|---|---|
+| `SCOUT_AGENT_API` | `http://localhost:3001` | Base URL of the ScoutAgent Runtime API |
+
+### Claude Desktop
+
+Add to your `claude_desktop_config.json`:
+
+```json
+{
+  "mcpServers": {
+    "scoutagent-xlayer": {
+      "command": "npx",
+      "args": ["-y", "@scoutagent/mcp-server"],
+      "env": {
+        "SCOUT_AGENT_API": "http://localhost:3001"
+      }
+    }
+  }
+}
+```
+
+### Cursor
+
+Add to your `.cursor/mcp.json`:
+
+```json
+{
+  "mcpServers": {
+    "scoutagent-xlayer": {
+      "command": "npx",
+      "args": ["-y", "@scoutagent/mcp-server"],
+      "env": {
+        "SCOUT_AGENT_API": "http://localhost:3001"
+      }
+    }
+  }
+}
+```
+
+## Available Tools
+
+### `xlayer_list_markets`
+
+List all ScoutAgent prediction markets on X Layer.
+
+| Parameter | Type | Required | Description |
+|---|---|---|---|
+| `status` | `OPEN \| LOCKED \| RESOLVED` | No | Filter by market status |
+| `matchDateFrom` | `string` (ISO 8601) | No | Filter matches from this date |
+| `matchDateTo` | `string` (ISO 8601) | No | Filter matches up to this date |
+
+### `xlayer_get_market`
+
+Get detailed information about a single prediction market.
+
+| Parameter | Type | Required | Description |
+|---|---|---|---|
+| `marketId` | `string` | Yes | The market ID to look up |
+
+### `xlayer_mint_agent`
+
+Mint a new AI Scout Agent NFT on X Layer.
+
+| Parameter | Type | Required | Description |
+|---|---|---|---|
+| `riskLevel` | `number` (1-5) | Yes | Risk appetite from 1 (conservative) to 5 (degen) |
+| `style` | `ATTACKING \| DEFENSIVE \| DATA_DRIVEN \| CONTRARIAN \| MOMENTUM` | Yes | Betting strategy style |
+| `bankrollPct` | `number` (1-100) | Yes | Percentage of bankroll to use per bet |
+| `favoriteTeams` | `string[]` | No | Favorite team names for bias weighting |
+
+### `xlayer_place_bet`
+
+Place a bet on a prediction market using an AI Scout Agent.
+
+| Parameter | Type | Required | Description |
+|---|---|---|---|
+| `agentId` | `string` | Yes | The agent ID placing the bet |
+| `marketId` | `string` | Yes | The market ID to bet on |
+| `outcome` | `HOME \| DRAW \| AWAY` | Yes | Predicted outcome |
+| `amount` | `string` | Yes | Bet amount in OKB (e.g. `"0.5"`) |
+
+### `xlayer_get_agent_stats`
+
+Get performance statistics for an AI Scout Agent.
+
+| Parameter | Type | Required | Description |
+|---|---|---|---|
+| `agentId` | `string` | Yes | The agent ID |
+
+### `xlayer_leaderboard`
+
+Get the ScoutAgent leaderboard ranked by PnL.
+
+| Parameter | Type | Required | Description |
+|---|---|---|---|
+| `top` | `number` (1-100) | No | Number of agents to return (default 10) |
+| `period` | `24h \| 7d \| all` | No | Leaderboard time period |
+
+### `xlayer_natural_intent`
+
+Parse natural language into a ScoutAgent action intent.
+
+| Parameter | Type | Required | Description |
+|---|---|---|---|
+| `text` | `string` | Yes | Natural language input |
+| `agentId` | `string` | No | Agent ID for context-aware parsing |
+
+## Available Resources
+
+### `xlayer://match/{matchId}`
+
+Returns detailed match data as JSON, including team names, date, venue, and statistics.
+
+### `xlayer://agent/{agentId}/strategy`
+
+Returns the strategy gene configuration for an AI Scout Agent as JSON, including style, risk level, and weighting parameters.
+
+## Usage Examples
+
+**In Claude Desktop or Cursor chat:**
+
+> "Show me all open prediction markets"
+
+> "Mint me an aggressive agent with risk level 4, ATTACKING style, and 20% bankroll"
+
+> "Place a 0.5 OKB bet on Brazil to win using agent abc123"
+
+> "How is my agent xyz789 performing?"
+
+> "Show me the top 5 agents this week"
+
+> "I want to bet on the underdog in the next match" (uses natural intent parsing)
+
+## Development
+
+```bash
+# Install dependencies
+pnpm install
+
+# Run in development mode
+pnpm dev
+
+# Build for production
+pnpm build
+
+# Type-check
+pnpm lint
+```
+
+## Architecture
+
+```
+src/
+  index.ts              MCP server entry point (stdio transport)
+  types.ts              Shared TypeScript types
+  clients.ts            HTTP client for ScoutAgent Runtime API
+  tools/
+    list_markets.ts     xlayer_list_markets tool
+    get_market.ts       xlayer_get_market tool
+    mint_agent.ts       xlayer_mint_agent tool
+    place_bet.ts        xlayer_place_bet tool
+    get_agent_stats.ts  xlayer_get_agent_stats tool
+    leaderboard.ts      xlayer_leaderboard tool
+    natural_intent.ts   xlayer_natural_intent tool
+  resources/
+    match_data.ts       xlayer://match/{matchId} resource
+    agent_strategies.ts xlayer://agent/{agentId}/strategy resource
+```
+
+## Publishing
+
+To publish the package to npm:
+
+```bash
+npm login
+cd apps/mcp-server
+npm publish --access public
+```
+
+> **Fallback package name:** If the scoped name `@scoutagent/mcp-server` is
+> unavailable or causes issues with npm (e.g., scope not claimed), change the
+> `name` field in `package.json` to `scoutagent-mcp` and publish again. The CLI
+> binary name (`scoutagent-mcp`) stays the same either way.
+
+## License
+
+MIT

package/dist/index.cjs

@@ -0,0 +1,538 @@
+#!/usr/bin/env node
+
+// src/index.ts
+var import_server = require("@modelcontextprotocol/sdk/server/index.js");
+var import_stdio = require("@modelcontextprotocol/sdk/server/stdio.js");
+var import_types = require("@modelcontextprotocol/sdk/types.js");
+
+// src/tools/list_markets.ts
+var import_zod = require("zod");
+
+// src/clients.ts
+var BASE_URL = process.env.SCOUT_AGENT_API?.replace(/\/+$/, "") ?? "http://localhost:3001";
+async function apiGet(path, query) {
+  const url = new URL(path, BASE_URL);
+  if (query) {
+    for (const [k, v] of Object.entries(query)) {
+      if (v !== void 0 && v !== "") url.searchParams.set(k, v);
+    }
+  }
+  const res = await fetch(url.toString(), {
+    method: "GET",
+    headers: { Accept: "application/json" }
+  });
+  const data = await res.json();
+  return { ok: res.ok, status: res.status, data };
+}
+async function apiPost(path, body) {
+  const res = await fetch(new URL(path, BASE_URL).toString(), {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Accept: "application/json"
+    },
+    body: JSON.stringify(body)
+  });
+  const data = await res.json();
+  return { ok: res.ok, status: res.status, data };
+}
+
+// src/tools/list_markets.ts
+var listMarketsSchema = import_zod.z.object({
+  status: import_zod.z.enum(["OPEN", "LOCKED", "RESOLVED"]).optional().describe("Filter by market status"),
+  matchDateFrom: import_zod.z.string().optional().describe("Filter matches from this date (ISO 8601)"),
+  matchDateTo: import_zod.z.string().optional().describe("Filter matches up to this date (ISO 8601)")
+});
+var listMarketsDef = {
+  name: "xlayer_list_markets",
+  description: "List all ScoutAgent prediction markets on X Layer. Optionally filter by status or match date range.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      status: {
+        type: "string",
+        enum: ["OPEN", "LOCKED", "RESOLVED"],
+        description: "Filter by market status"
+      },
+      matchDateFrom: {
+        type: "string",
+        description: "Filter matches from this date (ISO 8601)"
+      },
+      matchDateTo: {
+        type: "string",
+        description: "Filter matches up to this date (ISO 8601)"
+      }
+    }
+  }
+};
+async function handleListMarkets(params) {
+  const parsed = listMarketsSchema.parse(params);
+  const res = await apiGet("/api/markets", {
+    status: parsed.status,
+    matchDateFrom: parsed.matchDateFrom,
+    matchDateTo: parsed.matchDateTo
+  });
+  if (!res.ok) {
+    return {
+      content: [{ type: "text", text: `API error ${res.status}: ${JSON.stringify(res.data)}` }],
+      isError: true
+    };
+  }
+  const markets = res.data;
+  const summary = markets.map(
+    (m) => `[${m.id}] ${m.homeTeam} vs ${m.awayTeam} | ${m.matchDate} | ${m.status} | Pool: ${m.totalPool}`
+  );
+  return {
+    content: [
+      {
+        type: "text",
+        text: markets.length === 0 ? "No markets found matching the criteria." : `Found ${markets.length} market(s):
+
+${summary.join("\n")}`
+      }
+    ]
+  };
+}
+
+// src/tools/get_market.ts
+var import_zod2 = require("zod");
+var getMarketSchema = import_zod2.z.object({
+  marketId: import_zod2.z.string().describe("The market ID to look up")
+});
+var getMarketDef = {
+  name: "xlayer_get_market",
+  description: "Get detailed information about a single ScoutAgent prediction market on X Layer, including odds and pool size.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      marketId: {
+        type: "string",
+        description: "The market ID to look up"
+      }
+    },
+    required: ["marketId"]
+  }
+};
+async function handleGetMarket(params) {
+  const { marketId } = getMarketSchema.parse(params);
+  const res = await apiGet(`/api/markets/${marketId}`);
+  if (!res.ok) {
+    return {
+      content: [{ type: "text", text: `API error ${res.status}: ${JSON.stringify(res.data)}` }],
+      isError: true
+    };
+  }
+  const m = res.data;
+  const text = [
+    `Market: ${m.id}`,
+    `Match: ${m.homeTeam} vs ${m.awayTeam}`,
+    `Date: ${m.matchDate}`,
+    `Status: ${m.status}`,
+    `Odds: Home ${m.odds.home} | Draw ${m.odds.draw} | Away ${m.odds.away}`,
+    `Total Pool: ${m.totalPool}`,
+    m.resolvedOutcome ? `Resolved Outcome: ${m.resolvedOutcome}` : null
+  ].filter(Boolean).join("\n");
+  return { content: [{ type: "text", text }] };
+}
+
+// src/tools/mint_agent.ts
+var import_zod3 = require("zod");
+var mintAgentSchema = import_zod3.z.object({
+  riskLevel: import_zod3.z.number().int().min(1).max(5).describe("Risk appetite from 1 (conservative) to 5 (degen)"),
+  style: import_zod3.z.enum(["ATTACKING", "DEFENSIVE", "DATA_DRIVEN", "CONTRARIAN", "MOMENTUM"]).describe("Betting strategy style"),
+  bankrollPct: import_zod3.z.number().min(1).max(100).describe("Percentage of bankroll to use per bet (1-100)"),
+  favoriteTeams: import_zod3.z.array(import_zod3.z.string()).optional().default([]).describe("Optional list of favorite team names for bias weighting")
+});
+var mintAgentDef = {
+  name: "xlayer_mint_agent",
+  description: "Mint a new AI Scout Agent NFT on X Layer. The agent will autonomously bet on World Cup prediction markets based on its strategy gene.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      riskLevel: {
+        type: "number",
+        minimum: 1,
+        maximum: 5,
+        description: "Risk appetite from 1 (conservative) to 5 (degen)"
+      },
+      style: {
+        type: "string",
+        enum: ["ATTACKING", "DEFENSIVE", "DATA_DRIVEN", "CONTRARIAN", "MOMENTUM"],
+        description: "Betting strategy style"
+      },
+      bankrollPct: {
+        type: "number",
+        minimum: 1,
+        maximum: 100,
+        description: "Percentage of bankroll to use per bet (1-100)"
+      },
+      favoriteTeams: {
+        type: "array",
+        items: { type: "string" },
+        description: "Optional list of favorite team names for bias weighting"
+      }
+    },
+    required: ["riskLevel", "style", "bankrollPct"]
+  }
+};
+async function handleMintAgent(params) {
+  const parsed = mintAgentSchema.parse(params);
+  const res = await apiPost("/api/agents/mint", parsed);
+  if (!res.ok) {
+    return {
+      content: [{ type: "text", text: `API error ${res.status}: ${JSON.stringify(res.data)}` }],
+      isError: true
+    };
+  }
+  const a = res.data;
+  const text = [
+    `Agent minted successfully!`,
+    `Agent ID: ${a.agentId}`,
+    `Token ID: ${a.tokenId}`,
+    `Wallet: ${a.walletAddress}`,
+    `Style: ${a.style} | Risk: ${a.riskLevel} | Bankroll%: ${a.bankrollPct}`,
+    a.favoriteTeams.length > 0 ? `Favorite Teams: ${a.favoriteTeams.join(", ")}` : null
+  ].filter(Boolean).join("\n");
+  return { content: [{ type: "text", text }] };
+}
+
+// src/tools/place_bet.ts
+var import_zod4 = require("zod");
+var placeBetSchema = import_zod4.z.object({
+  agentId: import_zod4.z.string().describe("The agent ID placing the bet"),
+  marketId: import_zod4.z.string().describe("The market ID to bet on"),
+  outcome: import_zod4.z.enum(["HOME", "DRAW", "AWAY"]).describe("Predicted outcome: HOME, DRAW, or AWAY"),
+  amount: import_zod4.z.string().describe("Bet amount in OKB (as a decimal string, e.g. '0.5')")
+});
+var placeBetDef = {
+  name: "xlayer_place_bet",
+  description: "Place a bet on a ScoutAgent prediction market on X Layer using an AI Scout Agent. Returns the transaction hash and explorer URL.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      agentId: {
+        type: "string",
+        description: "The agent ID placing the bet"
+      },
+      marketId: {
+        type: "string",
+        description: "The market ID to bet on"
+      },
+      outcome: {
+        type: "string",
+        enum: ["HOME", "DRAW", "AWAY"],
+        description: "Predicted outcome: HOME, DRAW, or AWAY"
+      },
+      amount: {
+        type: "string",
+        description: "Bet amount in OKB (as a decimal string, e.g. '0.5')"
+      }
+    },
+    required: ["agentId", "marketId", "outcome", "amount"]
+  }
+};
+async function handlePlaceBet(params) {
+  const parsed = placeBetSchema.parse(params);
+  const res = await apiPost("/api/bets", parsed);
+  if (!res.ok) {
+    return {
+      content: [{ type: "text", text: `API error ${res.status}: ${JSON.stringify(res.data)}` }],
+      isError: true
+    };
+  }
+  const b = res.data;
+  const text = [
+    `Bet placed successfully!`,
+    `Tx Hash: ${b.txHash}`,
+    `Explorer: ${b.explorerUrl}`,
+    `Market: ${b.marketId} | Outcome: ${b.outcome} | Amount: ${b.amount}`,
+    `Estimated Payout: ${b.estimatedPayout}`
+  ].join("\n");
+  return { content: [{ type: "text", text }] };
+}
+
+// src/tools/get_agent_stats.ts
+var import_zod5 = require("zod");
+var getAgentStatsSchema = import_zod5.z.object({
+  agentId: import_zod5.z.string().describe("The agent ID to get statistics for")
+});
+var getAgentStatsDef = {
+  name: "xlayer_get_agent_stats",
+  description: "Get performance statistics for an AI Scout Agent on X Layer, including win rate, PnL, ROI, and streak.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      agentId: {
+        type: "string",
+        description: "The agent ID to get statistics for"
+      }
+    },
+    required: ["agentId"]
+  }
+};
+async function handleGetAgentStats(params) {
+  const { agentId } = getAgentStatsSchema.parse(params);
+  const res = await apiGet(`/api/agents/${agentId}/stats`);
+  if (!res.ok) {
+    return {
+      content: [{ type: "text", text: `API error ${res.status}: ${JSON.stringify(res.data)}` }],
+      isError: true
+    };
+  }
+  const s = res.data;
+  const text = [
+    `Agent ${s.agentId} Stats`,
+    `\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500`,
+    `Record: ${s.wins}W / ${s.losses}L / ${s.draws}D (${s.totalBets} total bets)`,
+    `Win Rate: ${(s.winRate * 100).toFixed(1)}%`,
+    `Total PnL: ${s.totalPnl} OKB`,
+    `ROI: ${(s.roi * 100).toFixed(1)}%`,
+    `Current Streak: ${s.streak > 0 ? `${s.streak}W` : s.streak < 0 ? `${Math.abs(s.streak)}L` : "0"}`
+  ].join("\n");
+  return { content: [{ type: "text", text }] };
+}
+
+// src/tools/leaderboard.ts
+var import_zod6 = require("zod");
+var leaderboardSchema = import_zod6.z.object({
+  top: import_zod6.z.number().int().min(1).max(100).optional().default(10).describe("Number of top agents to return (default 10)"),
+  period: import_zod6.z.enum(["24h", "7d", "all"]).optional().describe("Leaderboard time period: 24h, 7d, or all")
+});
+var leaderboardDef = {
+  name: "xlayer_leaderboard",
+  description: "Get the ScoutAgent leaderboard on X Layer, ranked by PnL. Filter by time period.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      top: {
+        type: "number",
+        minimum: 1,
+        maximum: 100,
+        description: "Number of top agents to return (default 10)"
+      },
+      period: {
+        type: "string",
+        enum: ["24h", "7d", "all"],
+        description: "Leaderboard time period: 24h, 7d, or all"
+      }
+    }
+  }
+};
+async function handleLeaderboard(params) {
+  const parsed = leaderboardSchema.parse(params);
+  const res = await apiGet("/api/leaderboard", {
+    top: String(parsed.top),
+    period: parsed.period
+  });
+  if (!res.ok) {
+    return {
+      content: [{ type: "text", text: `API error ${res.status}: ${JSON.stringify(res.data)}` }],
+      isError: true
+    };
+  }
+  const entries = res.data;
+  if (entries.length === 0) {
+    return { content: [{ type: "text", text: "Leaderboard is empty." }] };
+  }
+  const header = `ScoutAgent Leaderboard${parsed.period ? ` (${parsed.period})` : ""}
+${"\u2550".repeat(50)}`;
+  const rows = entries.map(
+    (e) => `#${e.rank} | Agent ${e.agentId} | PnL: ${e.pnl} OKB | WR: ${(e.winRate * 100).toFixed(1)}% | ${e.totalBets} bets | ${e.style}`
+  );
+  return { content: [{ type: "text", text: `${header}
+${rows.join("\n")}` }] };
+}
+
+// src/tools/natural_intent.ts
+var import_zod7 = require("zod");
+var naturalIntentSchema = import_zod7.z.object({
+  text: import_zod7.z.string().describe("Natural language text describing what the user wants to do"),
+  agentId: import_zod7.z.string().optional().describe("Optional agent ID for context-aware intent parsing")
+});
+var naturalIntentDef = {
+  name: "xlayer_natural_intent",
+  description: 'Parse natural language into a ScoutAgent action intent. For example: "bet 0.5 OKB on Brazil to win" becomes a structured place_bet intent.',
+  inputSchema: {
+    type: "object",
+    properties: {
+      text: {
+        type: "string",
+        description: "Natural language text describing what the user wants to do"
+      },
+      agentId: {
+        type: "string",
+        description: "Optional agent ID for context-aware intent parsing"
+      }
+    },
+    required: ["text"]
+  }
+};
+async function handleNaturalIntent(params) {
+  const parsed = naturalIntentSchema.parse(params);
+  const res = await apiPost("/api/intent", parsed);
+  if (!res.ok) {
+    return {
+      content: [{ type: "text", text: `API error ${res.status}: ${JSON.stringify(res.data)}` }],
+      isError: true
+    };
+  }
+  const r = res.data;
+  const text = [
+    `Intent: ${r.intent}`,
+    `Confidence: ${(r.confidence * 100).toFixed(0)}%`,
+    `Parameters: ${JSON.stringify(r.params, null, 2)}`,
+    r.suggestedAction ? `
+Suggested action: ${r.suggestedAction}` : null
+  ].filter(Boolean).join("\n");
+  return { content: [{ type: "text", text }] };
+}
+
+// src/resources/match_data.ts
+async function handleMatchData(matchId) {
+  const res = await apiGet(`/api/matches/${matchId}`);
+  if (!res.ok) {
+    return {
+      contents: [
+        {
+          uri: `xlayer://match/${matchId}`,
+          mimeType: "application/json",
+          text: JSON.stringify({ error: `API error ${res.status}`, details: res.data })
+        }
+      ]
+    };
+  }
+  return {
+    contents: [
+      {
+        uri: `xlayer://match/${matchId}`,
+        mimeType: "application/json",
+        text: JSON.stringify(res.data, null, 2)
+      }
+    ]
+  };
+}
+
+// src/resources/agent_strategies.ts
+async function handleAgentStrategy(agentId) {
+  const res = await apiGet(`/api/agents/${agentId}/strategy`);
+  if (!res.ok) {
+    return {
+      contents: [
+        {
+          uri: `xlayer://agent/${agentId}/strategy`,
+          mimeType: "application/json",
+          text: JSON.stringify({ error: `API error ${res.status}`, details: res.data })
+        }
+      ]
+    };
+  }
+  return {
+    contents: [
+      {
+        uri: `xlayer://agent/${agentId}/strategy`,
+        mimeType: "application/json",
+        text: JSON.stringify(res.data, null, 2)
+      }
+    ]
+  };
+}
+
+// src/index.ts
+var server = new import_server.Server(
+  { name: "scoutagent-xlayer", version: "0.1.0" },
+  {
+    capabilities: {
+      tools: {},
+      resources: {}
+    }
+  }
+);
+var TOOLS = [
+  listMarketsDef,
+  getMarketDef,
+  mintAgentDef,
+  placeBetDef,
+  getAgentStatsDef,
+  leaderboardDef,
+  naturalIntentDef
+];
+var TOOL_HANDLERS = {
+  [listMarketsDef.name]: handleListMarkets,
+  [getMarketDef.name]: handleGetMarket,
+  [mintAgentDef.name]: handleMintAgent,
+  [placeBetDef.name]: handlePlaceBet,
+  [getAgentStatsDef.name]: handleGetAgentStats,
+  [leaderboardDef.name]: handleLeaderboard,
+  [naturalIntentDef.name]: handleNaturalIntent
+};
+var RESOURCE_TEMPLATES = [
+  {
+    uriTemplate: "xlayer://match/{matchId}",
+    name: "Match Data",
+    description: "Detailed match data including teams, date, venue, and statistics.",
+    mimeType: "application/json"
+  },
+  {
+    uriTemplate: "xlayer://agent/{agentId}/strategy",
+    name: "Agent Strategy Gene",
+    description: "Strategy gene configuration for an AI Scout Agent.",
+    mimeType: "application/json"
+  }
+];
+server.setRequestHandler(import_types.ListToolsRequestSchema, async () => {
+  return { tools: TOOLS };
+});
+server.setRequestHandler(import_types.CallToolRequestSchema, async (request) => {
+  const { name, arguments: args } = request.params;
+  const handler = TOOL_HANDLERS[name];
+  if (!handler) {
+    return {
+      content: [{ type: "text", text: `Unknown tool: ${name}` }],
+      isError: true
+    };
+  }
+  try {
+    return await handler(args ?? {});
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return {
+      content: [{ type: "text", text: `Error executing ${name}: ${message}` }],
+      isError: true
+    };
+  }
+});
+server.setRequestHandler(import_types.ListResourcesRequestSchema, async () => {
+  return { resources: [] };
+});
+server.setRequestHandler(import_types.ListResourceTemplatesRequestSchema, async () => {
+  return { resourceTemplates: RESOURCE_TEMPLATES };
+});
+server.setRequestHandler(import_types.ReadResourceRequestSchema, async (request) => {
+  const { uri } = request.params;
+  const matchMatch = uri.match(/^xlayer:\/\/match\/(.+)$/);
+  if (matchMatch) {
+    return await handleMatchData(matchMatch[1]);
+  }
+  const strategyMatch = uri.match(/^xlayer:\/\/agent\/(.+)\/strategy$/);
+  if (strategyMatch) {
+    return await handleAgentStrategy(strategyMatch[1]);
+  }
+  return {
+    contents: [
+      {
+        uri,
+        mimeType: "text/plain",
+        text: `Unknown resource URI: ${uri}`
+      }
+    ]
+  };
+});
+async function main() {
+  const transport = new import_stdio.StdioServerTransport();
+  await server.connect(transport);
+  console.error("ScoutAgent MCP Server running on stdio");
+}
+main().catch((err) => {
+  console.error("Fatal error starting ScoutAgent MCP Server:", err);
+  process.exit(1);
+});

package/dist/index.d.cts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/index.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/index.js

@@ -0,0 +1,544 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+  ListResourcesRequestSchema,
+  ListResourceTemplatesRequestSchema,
+  ReadResourceRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+
+// src/tools/list_markets.ts
+import { z } from "zod";
+
+// src/clients.ts
+var BASE_URL = process.env.SCOUT_AGENT_API?.replace(/\/+$/, "") ?? "http://localhost:3001";
+async function apiGet(path, query) {
+  const url = new URL(path, BASE_URL);
+  if (query) {
+    for (const [k, v] of Object.entries(query)) {
+      if (v !== void 0 && v !== "") url.searchParams.set(k, v);
+    }
+  }
+  const res = await fetch(url.toString(), {
+    method: "GET",
+    headers: { Accept: "application/json" }
+  });
+  const data = await res.json();
+  return { ok: res.ok, status: res.status, data };
+}
+async function apiPost(path, body) {
+  const res = await fetch(new URL(path, BASE_URL).toString(), {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Accept: "application/json"
+    },
+    body: JSON.stringify(body)
+  });
+  const data = await res.json();
+  return { ok: res.ok, status: res.status, data };
+}
+
+// src/tools/list_markets.ts
+var listMarketsSchema = z.object({
+  status: z.enum(["OPEN", "LOCKED", "RESOLVED"]).optional().describe("Filter by market status"),
+  matchDateFrom: z.string().optional().describe("Filter matches from this date (ISO 8601)"),
+  matchDateTo: z.string().optional().describe("Filter matches up to this date (ISO 8601)")
+});
+var listMarketsDef = {
+  name: "xlayer_list_markets",
+  description: "List all ScoutAgent prediction markets on X Layer. Optionally filter by status or match date range.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      status: {
+        type: "string",
+        enum: ["OPEN", "LOCKED", "RESOLVED"],
+        description: "Filter by market status"
+      },
+      matchDateFrom: {
+        type: "string",
+        description: "Filter matches from this date (ISO 8601)"
+      },
+      matchDateTo: {
+        type: "string",
+        description: "Filter matches up to this date (ISO 8601)"
+      }
+    }
+  }
+};
+async function handleListMarkets(params) {
+  const parsed = listMarketsSchema.parse(params);
+  const res = await apiGet("/api/markets", {
+    status: parsed.status,
+    matchDateFrom: parsed.matchDateFrom,
+    matchDateTo: parsed.matchDateTo
+  });
+  if (!res.ok) {
+    return {
+      content: [{ type: "text", text: `API error ${res.status}: ${JSON.stringify(res.data)}` }],
+      isError: true
+    };
+  }
+  const markets = res.data;
+  const summary = markets.map(
+    (m) => `[${m.id}] ${m.homeTeam} vs ${m.awayTeam} | ${m.matchDate} | ${m.status} | Pool: ${m.totalPool}`
+  );
+  return {
+    content: [
+      {
+        type: "text",
+        text: markets.length === 0 ? "No markets found matching the criteria." : `Found ${markets.length} market(s):
+
+${summary.join("\n")}`
+      }
+    ]
+  };
+}
+
+// src/tools/get_market.ts
+import { z as z2 } from "zod";
+var getMarketSchema = z2.object({
+  marketId: z2.string().describe("The market ID to look up")
+});
+var getMarketDef = {
+  name: "xlayer_get_market",
+  description: "Get detailed information about a single ScoutAgent prediction market on X Layer, including odds and pool size.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      marketId: {
+        type: "string",
+        description: "The market ID to look up"
+      }
+    },
+    required: ["marketId"]
+  }
+};
+async function handleGetMarket(params) {
+  const { marketId } = getMarketSchema.parse(params);
+  const res = await apiGet(`/api/markets/${marketId}`);
+  if (!res.ok) {
+    return {
+      content: [{ type: "text", text: `API error ${res.status}: ${JSON.stringify(res.data)}` }],
+      isError: true
+    };
+  }
+  const m = res.data;
+  const text = [
+    `Market: ${m.id}`,
+    `Match: ${m.homeTeam} vs ${m.awayTeam}`,
+    `Date: ${m.matchDate}`,
+    `Status: ${m.status}`,
+    `Odds: Home ${m.odds.home} | Draw ${m.odds.draw} | Away ${m.odds.away}`,
+    `Total Pool: ${m.totalPool}`,
+    m.resolvedOutcome ? `Resolved Outcome: ${m.resolvedOutcome}` : null
+  ].filter(Boolean).join("\n");
+  return { content: [{ type: "text", text }] };
+}
+
+// src/tools/mint_agent.ts
+import { z as z3 } from "zod";
+var mintAgentSchema = z3.object({
+  riskLevel: z3.number().int().min(1).max(5).describe("Risk appetite from 1 (conservative) to 5 (degen)"),
+  style: z3.enum(["ATTACKING", "DEFENSIVE", "DATA_DRIVEN", "CONTRARIAN", "MOMENTUM"]).describe("Betting strategy style"),
+  bankrollPct: z3.number().min(1).max(100).describe("Percentage of bankroll to use per bet (1-100)"),
+  favoriteTeams: z3.array(z3.string()).optional().default([]).describe("Optional list of favorite team names for bias weighting")
+});
+var mintAgentDef = {
+  name: "xlayer_mint_agent",
+  description: "Mint a new AI Scout Agent NFT on X Layer. The agent will autonomously bet on World Cup prediction markets based on its strategy gene.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      riskLevel: {
+        type: "number",
+        minimum: 1,
+        maximum: 5,
+        description: "Risk appetite from 1 (conservative) to 5 (degen)"
+      },
+      style: {
+        type: "string",
+        enum: ["ATTACKING", "DEFENSIVE", "DATA_DRIVEN", "CONTRARIAN", "MOMENTUM"],
+        description: "Betting strategy style"
+      },
+      bankrollPct: {
+        type: "number",
+        minimum: 1,
+        maximum: 100,
+        description: "Percentage of bankroll to use per bet (1-100)"
+      },
+      favoriteTeams: {
+        type: "array",
+        items: { type: "string" },
+        description: "Optional list of favorite team names for bias weighting"
+      }
+    },
+    required: ["riskLevel", "style", "bankrollPct"]
+  }
+};
+async function handleMintAgent(params) {
+  const parsed = mintAgentSchema.parse(params);
+  const res = await apiPost("/api/agents/mint", parsed);
+  if (!res.ok) {
+    return {
+      content: [{ type: "text", text: `API error ${res.status}: ${JSON.stringify(res.data)}` }],
+      isError: true
+    };
+  }
+  const a = res.data;
+  const text = [
+    `Agent minted successfully!`,
+    `Agent ID: ${a.agentId}`,
+    `Token ID: ${a.tokenId}`,
+    `Wallet: ${a.walletAddress}`,
+    `Style: ${a.style} | Risk: ${a.riskLevel} | Bankroll%: ${a.bankrollPct}`,
+    a.favoriteTeams.length > 0 ? `Favorite Teams: ${a.favoriteTeams.join(", ")}` : null
+  ].filter(Boolean).join("\n");
+  return { content: [{ type: "text", text }] };
+}
+
+// src/tools/place_bet.ts
+import { z as z4 } from "zod";
+var placeBetSchema = z4.object({
+  agentId: z4.string().describe("The agent ID placing the bet"),
+  marketId: z4.string().describe("The market ID to bet on"),
+  outcome: z4.enum(["HOME", "DRAW", "AWAY"]).describe("Predicted outcome: HOME, DRAW, or AWAY"),
+  amount: z4.string().describe("Bet amount in OKB (as a decimal string, e.g. '0.5')")
+});
+var placeBetDef = {
+  name: "xlayer_place_bet",
+  description: "Place a bet on a ScoutAgent prediction market on X Layer using an AI Scout Agent. Returns the transaction hash and explorer URL.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      agentId: {
+        type: "string",
+        description: "The agent ID placing the bet"
+      },
+      marketId: {
+        type: "string",
+        description: "The market ID to bet on"
+      },
+      outcome: {
+        type: "string",
+        enum: ["HOME", "DRAW", "AWAY"],
+        description: "Predicted outcome: HOME, DRAW, or AWAY"
+      },
+      amount: {
+        type: "string",
+        description: "Bet amount in OKB (as a decimal string, e.g. '0.5')"
+      }
+    },
+    required: ["agentId", "marketId", "outcome", "amount"]
+  }
+};
+async function handlePlaceBet(params) {
+  const parsed = placeBetSchema.parse(params);
+  const res = await apiPost("/api/bets", parsed);
+  if (!res.ok) {
+    return {
+      content: [{ type: "text", text: `API error ${res.status}: ${JSON.stringify(res.data)}` }],
+      isError: true
+    };
+  }
+  const b = res.data;
+  const text = [
+    `Bet placed successfully!`,
+    `Tx Hash: ${b.txHash}`,
+    `Explorer: ${b.explorerUrl}`,
+    `Market: ${b.marketId} | Outcome: ${b.outcome} | Amount: ${b.amount}`,
+    `Estimated Payout: ${b.estimatedPayout}`
+  ].join("\n");
+  return { content: [{ type: "text", text }] };
+}
+
+// src/tools/get_agent_stats.ts
+import { z as z5 } from "zod";
+var getAgentStatsSchema = z5.object({
+  agentId: z5.string().describe("The agent ID to get statistics for")
+});
+var getAgentStatsDef = {
+  name: "xlayer_get_agent_stats",
+  description: "Get performance statistics for an AI Scout Agent on X Layer, including win rate, PnL, ROI, and streak.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      agentId: {
+        type: "string",
+        description: "The agent ID to get statistics for"
+      }
+    },
+    required: ["agentId"]
+  }
+};
+async function handleGetAgentStats(params) {
+  const { agentId } = getAgentStatsSchema.parse(params);
+  const res = await apiGet(`/api/agents/${agentId}/stats`);
+  if (!res.ok) {
+    return {
+      content: [{ type: "text", text: `API error ${res.status}: ${JSON.stringify(res.data)}` }],
+      isError: true
+    };
+  }
+  const s = res.data;
+  const text = [
+    `Agent ${s.agentId} Stats`,
+    `\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500`,
+    `Record: ${s.wins}W / ${s.losses}L / ${s.draws}D (${s.totalBets} total bets)`,
+    `Win Rate: ${(s.winRate * 100).toFixed(1)}%`,
+    `Total PnL: ${s.totalPnl} OKB`,
+    `ROI: ${(s.roi * 100).toFixed(1)}%`,
+    `Current Streak: ${s.streak > 0 ? `${s.streak}W` : s.streak < 0 ? `${Math.abs(s.streak)}L` : "0"}`
+  ].join("\n");
+  return { content: [{ type: "text", text }] };
+}
+
+// src/tools/leaderboard.ts
+import { z as z6 } from "zod";
+var leaderboardSchema = z6.object({
+  top: z6.number().int().min(1).max(100).optional().default(10).describe("Number of top agents to return (default 10)"),
+  period: z6.enum(["24h", "7d", "all"]).optional().describe("Leaderboard time period: 24h, 7d, or all")
+});
+var leaderboardDef = {
+  name: "xlayer_leaderboard",
+  description: "Get the ScoutAgent leaderboard on X Layer, ranked by PnL. Filter by time period.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      top: {
+        type: "number",
+        minimum: 1,
+        maximum: 100,
+        description: "Number of top agents to return (default 10)"
+      },
+      period: {
+        type: "string",
+        enum: ["24h", "7d", "all"],
+        description: "Leaderboard time period: 24h, 7d, or all"
+      }
+    }
+  }
+};
+async function handleLeaderboard(params) {
+  const parsed = leaderboardSchema.parse(params);
+  const res = await apiGet("/api/leaderboard", {
+    top: String(parsed.top),
+    period: parsed.period
+  });
+  if (!res.ok) {
+    return {
+      content: [{ type: "text", text: `API error ${res.status}: ${JSON.stringify(res.data)}` }],
+      isError: true
+    };
+  }
+  const entries = res.data;
+  if (entries.length === 0) {
+    return { content: [{ type: "text", text: "Leaderboard is empty." }] };
+  }
+  const header = `ScoutAgent Leaderboard${parsed.period ? ` (${parsed.period})` : ""}
+${"\u2550".repeat(50)}`;
+  const rows = entries.map(
+    (e) => `#${e.rank} | Agent ${e.agentId} | PnL: ${e.pnl} OKB | WR: ${(e.winRate * 100).toFixed(1)}% | ${e.totalBets} bets | ${e.style}`
+  );
+  return { content: [{ type: "text", text: `${header}
+${rows.join("\n")}` }] };
+}
+
+// src/tools/natural_intent.ts
+import { z as z7 } from "zod";
+var naturalIntentSchema = z7.object({
+  text: z7.string().describe("Natural language text describing what the user wants to do"),
+  agentId: z7.string().optional().describe("Optional agent ID for context-aware intent parsing")
+});
+var naturalIntentDef = {
+  name: "xlayer_natural_intent",
+  description: 'Parse natural language into a ScoutAgent action intent. For example: "bet 0.5 OKB on Brazil to win" becomes a structured place_bet intent.',
+  inputSchema: {
+    type: "object",
+    properties: {
+      text: {
+        type: "string",
+        description: "Natural language text describing what the user wants to do"
+      },
+      agentId: {
+        type: "string",
+        description: "Optional agent ID for context-aware intent parsing"
+      }
+    },
+    required: ["text"]
+  }
+};
+async function handleNaturalIntent(params) {
+  const parsed = naturalIntentSchema.parse(params);
+  const res = await apiPost("/api/intent", parsed);
+  if (!res.ok) {
+    return {
+      content: [{ type: "text", text: `API error ${res.status}: ${JSON.stringify(res.data)}` }],
+      isError: true
+    };
+  }
+  const r = res.data;
+  const text = [
+    `Intent: ${r.intent}`,
+    `Confidence: ${(r.confidence * 100).toFixed(0)}%`,
+    `Parameters: ${JSON.stringify(r.params, null, 2)}`,
+    r.suggestedAction ? `
+Suggested action: ${r.suggestedAction}` : null
+  ].filter(Boolean).join("\n");
+  return { content: [{ type: "text", text }] };
+}
+
+// src/resources/match_data.ts
+async function handleMatchData(matchId) {
+  const res = await apiGet(`/api/matches/${matchId}`);
+  if (!res.ok) {
+    return {
+      contents: [
+        {
+          uri: `xlayer://match/${matchId}`,
+          mimeType: "application/json",
+          text: JSON.stringify({ error: `API error ${res.status}`, details: res.data })
+        }
+      ]
+    };
+  }
+  return {
+    contents: [
+      {
+        uri: `xlayer://match/${matchId}`,
+        mimeType: "application/json",
+        text: JSON.stringify(res.data, null, 2)
+      }
+    ]
+  };
+}
+
+// src/resources/agent_strategies.ts
+async function handleAgentStrategy(agentId) {
+  const res = await apiGet(`/api/agents/${agentId}/strategy`);
+  if (!res.ok) {
+    return {
+      contents: [
+        {
+          uri: `xlayer://agent/${agentId}/strategy`,
+          mimeType: "application/json",
+          text: JSON.stringify({ error: `API error ${res.status}`, details: res.data })
+        }
+      ]
+    };
+  }
+  return {
+    contents: [
+      {
+        uri: `xlayer://agent/${agentId}/strategy`,
+        mimeType: "application/json",
+        text: JSON.stringify(res.data, null, 2)
+      }
+    ]
+  };
+}
+
+// src/index.ts
+var server = new Server(
+  { name: "scoutagent-xlayer", version: "0.1.0" },
+  {
+    capabilities: {
+      tools: {},
+      resources: {}
+    }
+  }
+);
+var TOOLS = [
+  listMarketsDef,
+  getMarketDef,
+  mintAgentDef,
+  placeBetDef,
+  getAgentStatsDef,
+  leaderboardDef,
+  naturalIntentDef
+];
+var TOOL_HANDLERS = {
+  [listMarketsDef.name]: handleListMarkets,
+  [getMarketDef.name]: handleGetMarket,
+  [mintAgentDef.name]: handleMintAgent,
+  [placeBetDef.name]: handlePlaceBet,
+  [getAgentStatsDef.name]: handleGetAgentStats,
+  [leaderboardDef.name]: handleLeaderboard,
+  [naturalIntentDef.name]: handleNaturalIntent
+};
+var RESOURCE_TEMPLATES = [
+  {
+    uriTemplate: "xlayer://match/{matchId}",
+    name: "Match Data",
+    description: "Detailed match data including teams, date, venue, and statistics.",
+    mimeType: "application/json"
+  },
+  {
+    uriTemplate: "xlayer://agent/{agentId}/strategy",
+    name: "Agent Strategy Gene",
+    description: "Strategy gene configuration for an AI Scout Agent.",
+    mimeType: "application/json"
+  }
+];
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+  return { tools: TOOLS };
+});
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  const { name, arguments: args } = request.params;
+  const handler = TOOL_HANDLERS[name];
+  if (!handler) {
+    return {
+      content: [{ type: "text", text: `Unknown tool: ${name}` }],
+      isError: true
+    };
+  }
+  try {
+    return await handler(args ?? {});
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return {
+      content: [{ type: "text", text: `Error executing ${name}: ${message}` }],
+      isError: true
+    };
+  }
+});
+server.setRequestHandler(ListResourcesRequestSchema, async () => {
+  return { resources: [] };
+});
+server.setRequestHandler(ListResourceTemplatesRequestSchema, async () => {
+  return { resourceTemplates: RESOURCE_TEMPLATES };
+});
+server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+  const { uri } = request.params;
+  const matchMatch = uri.match(/^xlayer:\/\/match\/(.+)$/);
+  if (matchMatch) {
+    return await handleMatchData(matchMatch[1]);
+  }
+  const strategyMatch = uri.match(/^xlayer:\/\/agent\/(.+)\/strategy$/);
+  if (strategyMatch) {
+    return await handleAgentStrategy(strategyMatch[1]);
+  }
+  return {
+    contents: [
+      {
+        uri,
+        mimeType: "text/plain",
+        text: `Unknown resource URI: ${uri}`
+      }
+    ]
+  };
+});
+async function main() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error("ScoutAgent MCP Server running on stdio");
+}
+main().catch((err) => {
+  console.error("Fatal error starting ScoutAgent MCP Server:", err);
+  process.exit(1);
+});

package/package.json

@@ -1,20 +1,70 @@
 {
   "name": "@scoutagent/mcp-server",
-  "version": "1.0.8",
-  "description": "MCP Server for ScoutAgent",
+  "version": "1.2.0",
+  "description": "MCP Server for ScoutAgent - AI Scout prediction market on X Layer",
+  "type": "module",
+  "main": "dist/index.cjs",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs",
+      "types": "./dist/index.d.ts"
+    }
+  },
   "bin": {
-    "mcp-server": "./index.js"
+    "scoutagentmcp": "./dist/index.cjs"
   },
+  "files": [
+    "dist",
+    "README.md"
+  ],
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "build": "tsup src/index.ts --format esm,cjs --dts",
+    "dev": "tsx src/index.ts",
+    "lint": "tsc --noEmit",
+    "clean": "rm -rf dist",
+    "prepublishOnly": "npm run build"
   },
   "keywords": [
     "mcp",
-    "scoutagent"
+    "model-context-protocol",
+    "scoutagent",
+    "prediction-market",
+    "xlayer",
+    "ai-agent",
+    "nft",
+    "okb",
+    "claude-desktop",
+    "cursor"
   ],
-  "author": "",
-  "license": "ISC",
+  "author": "ScoutAgent Team",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/0xCaptain888/scout-agent.git",
+    "directory": "apps/mcp-server"
+  },
+  "homepage": "https://github.com/0xCaptain888/scout-agent/tree/main/apps/mcp-server#readme",
+  "bugs": {
+    "url": "https://github.com/0xCaptain888/scout-agent/issues"
+  },
+  "engines": {
+    "node": ">=20"
+  },
   "publishConfig": {
     "access": "public"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.12.0",
+    "zod": "^3.24.0",
+    "node-fetch": "^3.3.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.7.0",
+    "tsx": "^4.19.0",
+    "tsup": "^8.4.0",
+    "@types/node": "^22.0.0"
   }
-}
+}

package/index.js

@@ -1,14 +0,0 @@
-#!/usr/bin/env node
-
-console.log("✅ @scoutagent/mcp-server 已启动");
-console.log("MCP Server for ScoutAgent");
-
-// 简单示例：接收命令行参数
-const args = process.argv.slice(2);
-if (args.length > 0) {
-  console.log("收到参数:", args);
-} else {
-  console.log("使用方法: npx @scoutagent/mcp-server [参数]");
-}
-
-// 这里以后可以添加真正的 MCP Server 逻辑