@dritan/mcp 0.1.1 → 0.3.0

package/.env.example

@@ -2,3 +2,4 @@ DRITAN_API_KEY=
 DRITAN_BASE_URL=https://us-east.dritan.dev
 DRITAN_WS_BASE_URL=wss://us-east.dritan.dev
 SOLANA_RPC_URL=https://api.mainnet-beta.solana.com
+METEORA_THS_BASE_URL=https://ths.dritan.dev

package/README.md

@@ -41,8 +41,30 @@ npm run build && npm start
 - `wallet_create_local`
 - `wallet_get_address`
 - `wallet_get_balance`
+- `dritan_health`
 - `market_get_snapshot`
+- `token_search`
+- `token_get_price`
+- `token_get_metadata`
+- `token_get_risk`
+- `token_get_first_buyers`
+- `token_get_aggregated`
+- `token_get_deployer_stats`
+- `token_get_ohlcv`
+- `token_get_ohlcv_chart`
+- `wallet_get_performance`
+- `wallet_get_token_performance`
+- `wallet_get_portfolio_chart`
+- `wallet_get_summary`
+- `wallet_get_trade_history`
+- `wallet_get_holdings`
+- `wallet_get_holdings_page`
 - `market_stream_sample`
+- `wallet_stream_sample`
+- `ths_health`
+- `ths_get_score`
+- `ths_get_score_tokens_get`
+- `ths_get_score_tokens_post`
 - `swap_build`
 - `swap_sign_and_broadcast`
 - `swap_build_sign_and_broadcast`
@@ -52,4 +74,7 @@ npm run build && npm start
 - Wallets default to `~/.config/dritan-mcp/wallets`.
 - Private keys never leave local files; only public address/signature are returned.
 - `swap_sign_and_broadcast` signs locally, then broadcasts via Dritan.
+- `token_get_ohlcv_chart` returns a shareable chart URL plus a ready-to-send markdown image snippet.
+- Ticker workflow for chart requests: `token_search` -> extract mint -> `token_get_ohlcv` or `token_get_ohlcv_chart`.
+- If users ask for `$WIF` style symbols, always resolve mint with `token_search` first.
 - If Solana CLI is missing, run `system_check_prereqs` and follow returned install steps.

package/dist/index.js

@@ -6,17 +6,36 @@ import { spawnSync } from "node:child_process";
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
-import { DritanClient } from "dritan-sdk";
+import { DritanClient, MeteoraThsClient, } from "dritan-sdk";
 import { Connection, Keypair, VersionedTransaction, clusterApiUrl } from "@solana/web3.js";
 import { z } from "zod";
 const DEFAULT_WALLET_DIR = join(homedir(), ".config", "dritan-mcp", "wallets");
+const STREAM_DEXES = [
+    "pumpamm",
+    "pumpfun",
+    "launchlab",
+    "dlmm",
+    "damm2",
+    "damm1",
+    "dbc",
+    "amm",
+    "cpmm",
+    "clmm",
+    "orca",
+];
 const server = new Server({
     name: "dritan-mcp",
-    version: "0.1.0",
+    version: "0.1.2",
 }, {
     capabilities: {
         tools: {},
     },
+    instructions: [
+        "This server requires a DRITAN_API_KEY environment variable to use market data and swap tools.",
+        "Get your API key at https://dritan.dev and configure it:",
+        "  claude mcp add dritan-mcp -e DRITAN_API_KEY=<your-key> -- npx @dritan/mcp@latest",
+        "Without the key, only system_check_prereqs and wallet tools (create_local, get_address, get_balance) will work.",
+    ].join("\n"),
 });
 function getDritanClient() {
     const apiKey = process.env.DRITAN_API_KEY;
@@ -29,6 +48,122 @@ function getDritanClient() {
         wsBaseUrl: process.env.DRITAN_WS_BASE_URL,
     });
 }
+function getThsClient() {
+    return new MeteoraThsClient({
+        baseUrl: process.env.METEORA_THS_BASE_URL,
+    });
+}
+async function searchTokens(client, query, options) {
+    const sdkSearch = client.searchTokens;
+    if (typeof sdkSearch === "function") {
+        return await sdkSearch(query, options);
+    }
+    // Backward-compatible fallback for environments where dritan-sdk hasn't been upgraded yet.
+    const apiKey = process.env.DRITAN_API_KEY;
+    if (!apiKey) {
+        throw new Error("Missing DRITAN_API_KEY in environment");
+    }
+    const baseUrl = process.env.DRITAN_BASE_URL ?? "https://us-east.dritan.dev";
+    const url = new URL("/token/search", baseUrl);
+    url.searchParams.set("query", query);
+    if (options?.limit !== undefined)
+        url.searchParams.set("limit", String(options.limit));
+    if (options?.cursor) {
+        url.searchParams.set("cursor", options.cursor);
+    }
+    else if (options?.page !== undefined) {
+        url.searchParams.set("page", String(options.page));
+    }
+    const response = await fetch(url.toString(), {
+        method: "GET",
+        headers: { "x-api-key": apiKey },
+    });
+    const text = await response.text();
+    if (!response.ok) {
+        throw new Error(`Token search failed (${response.status}): ${text}`);
+    }
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return { ok: true, raw: text };
+    }
+}
+async function checkDritanHealth() {
+    const baseUrl = process.env.DRITAN_BASE_URL ?? "https://us-east.dritan.dev";
+    const url = new URL("/health", baseUrl).toString();
+    const apiKey = process.env.DRITAN_API_KEY;
+    const headers = {};
+    if (apiKey)
+        headers["x-api-key"] = apiKey;
+    const response = await fetch(url, {
+        method: "GET",
+        headers,
+    });
+    const body = await response.text().catch(() => null);
+    return {
+        ok: response.ok,
+        status: response.status,
+        url,
+        body,
+    };
+}
+function toEpochMs(ts) {
+    return ts > 1_000_000_000_000 ? ts : ts * 1000;
+}
+function formatChartLabel(ts) {
+    const date = new Date(toEpochMs(ts));
+    if (Number.isNaN(date.getTime()))
+        return String(ts);
+    return date.toISOString().replace("T", " ").slice(0, 16);
+}
+function buildOhlcvChartUrl(mint, timeframe, bars, width, height) {
+    const labels = bars.map((bar) => formatChartLabel(bar.time));
+    const closeSeries = bars.map((bar) => Number(bar.close.toFixed(12)));
+    const volumeSeries = bars.map((bar) => Number(bar.volume.toFixed(12)));
+    const config = {
+        type: "bar",
+        data: {
+            labels,
+            datasets: [
+                {
+                    type: "line",
+                    label: "Close",
+                    data: closeSeries,
+                    borderColor: "#2563eb",
+                    backgroundColor: "rgba(37,99,235,0.2)",
+                    pointRadius: 0,
+                    borderWidth: 2,
+                    tension: 0.2,
+                    yAxisID: "price",
+                },
+                {
+                    type: "bar",
+                    label: "Volume",
+                    data: volumeSeries,
+                    backgroundColor: "rgba(16,185,129,0.25)",
+                    borderWidth: 0,
+                    yAxisID: "volume",
+                },
+            ],
+        },
+        options: {
+            plugins: {
+                legend: { display: true },
+                title: {
+                    display: true,
+                    text: `${mint} ${timeframe.toUpperCase()} OHLCV`,
+                },
+            },
+            scales: {
+                price: { type: "linear", position: "left" },
+                volume: { type: "linear", position: "right", grid: { drawOnChartArea: false } },
+            },
+        },
+    };
+    const encoded = encodeURIComponent(JSON.stringify(config));
+    return `https://quickchart.io/chart?w=${width}&h=${height}&f=png&c=${encoded}`;
+}
 function getPlatformInstallHint(binary) {
     switch (process.platform) {
         case "darwin":
@@ -143,11 +278,64 @@ const marketSnapshotSchema = z.object({
     mint: z.string().min(1),
     mode: z.enum(["price", "metadata", "risk", "first-buyers", "aggregated"]).default("aggregated"),
 });
+const tokenMintSchema = z.object({
+    mint: z.string().min(1),
+});
+const tokenSearchSchema = z.object({
+    query: z.string().min(1),
+    limit: z.number().int().min(1).max(50).optional(),
+    cursor: z.string().min(1).optional(),
+    page: z.number().int().min(1).optional(),
+});
 const marketStreamSampleSchema = z.object({
-    dex: z.enum(["pumpamm", "pumpfun", "launchlab", "dlmm", "damm2", "damm1", "dbc"]),
+    dex: z.enum(STREAM_DEXES),
     durationMs: z.number().int().min(500).max(60_000).default(10_000),
     maxEvents: z.number().int().min(1).max(250).default(20),
 });
+const tokenOhlcvSchema = z.object({
+    mint: z.string().min(1),
+    timeframe: z.string().min(1),
+    timeTo: z.number().int().positive().optional(),
+});
+const tokenOhlcvChartSchema = tokenOhlcvSchema.extend({
+    includeActive: z.boolean().default(true),
+    maxPoints: z.number().int().min(10).max(500).default(120),
+    width: z.number().int().min(300).max(2000).default(1200),
+    height: z.number().int().min(200).max(1200).default(600),
+});
+const walletAddressSchema = z.object({
+    wallet: z.string().min(1),
+});
+const walletPerformanceSchema = walletAddressSchema.extend({
+    showHistoricPnL: z.boolean().optional(),
+    holdingCheck: z.boolean().optional(),
+    hideDetails: z.boolean().optional(),
+});
+const walletTokenPerformanceSchema = walletAddressSchema.extend({
+    tokenMint: z.string().min(1),
+});
+const walletPortfolioChartSchema = walletAddressSchema.extend({
+    days: z.number().int().min(1).max(3650).optional(),
+});
+const walletTradeHistorySchema = walletAddressSchema.extend({
+    cursor: z.string().min(1).optional(),
+});
+const walletHoldingsPageSchema = walletAddressSchema.extend({
+    page: z.number().int().min(1),
+});
+const walletStreamSampleSchema = z.object({
+    wallets: z.array(z.string().min(1)).min(1).max(100),
+    durationMs: z.number().int().min(500).max(60_000).default(10_000),
+    maxEvents: z.number().int().min(1).max(250).default(20),
+});
+const thsScoreSchema = z.object({
+    wallet: z.string().min(1),
+    debug: z.boolean().optional(),
+    breakdown: z.boolean().optional(),
+});
+const thsScoreTokensSchema = thsScoreSchema.extend({
+    tokenMints: z.array(z.string().min(1)).min(1).max(200),
+});
 const swapBuildSchema = z.object({
     walletPath: z.string().min(1).optional(),
     userPublicKey: z.string().min(1).optional(),
@@ -207,6 +395,14 @@ const tools = [
             },
         },
     },
+    {
+        name: "dritan_health",
+        description: "Check data plane health endpoint via Dritan SDK.",
+        inputSchema: {
+            type: "object",
+            properties: {},
+        },
+    },
     {
         name: "market_get_snapshot",
         description: "Fetch token market snapshot via Dritan SDK (price/metadata/risk/first-buyers/aggregated).",
@@ -222,6 +418,200 @@ const tools = [
             },
         },
     },
+    {
+        name: "token_search",
+        description: "Search tokens by ticker/name and resolve mint addresses (first step for ticker-based chart requests).",
+        inputSchema: {
+            type: "object",
+            required: ["query"],
+            properties: {
+                query: { type: "string", description: "Ticker or token name, e.g. WIF or $WIF" },
+                limit: { type: "number", description: "Optional result limit (1-50)" },
+                cursor: { type: "string", description: "Optional cursor for pagination" },
+                page: { type: "number", description: "Optional page (used when cursor is absent)" },
+            },
+        },
+    },
+    {
+        name: "token_get_price",
+        description: "Fetch token price via Dritan (same as market_get_snapshot mode=price).",
+        inputSchema: {
+            type: "object",
+            required: ["mint"],
+            properties: {
+                mint: { type: "string" },
+            },
+        },
+    },
+    {
+        name: "token_get_metadata",
+        description: "Fetch token metadata via Dritan.",
+        inputSchema: {
+            type: "object",
+            required: ["mint"],
+            properties: {
+                mint: { type: "string" },
+            },
+        },
+    },
+    {
+        name: "token_get_risk",
+        description: "Fetch token risk via Dritan (same as market_get_snapshot mode=risk).",
+        inputSchema: {
+            type: "object",
+            required: ["mint"],
+            properties: {
+                mint: { type: "string" },
+            },
+        },
+    },
+    {
+        name: "token_get_first_buyers",
+        description: "Fetch first buyers via Dritan.",
+        inputSchema: {
+            type: "object",
+            required: ["mint"],
+            properties: {
+                mint: { type: "string" },
+            },
+        },
+    },
+    {
+        name: "token_get_aggregated",
+        description: "Fetch aggregated token data via Dritan (same as market_get_snapshot mode=aggregated).",
+        inputSchema: {
+            type: "object",
+            required: ["mint"],
+            properties: {
+                mint: { type: "string" },
+            },
+        },
+    },
+    {
+        name: "token_get_deployer_stats",
+        description: "Fetch token deployer stats via Dritan.",
+        inputSchema: {
+            type: "object",
+            required: ["mint"],
+            properties: {
+                mint: { type: "string" },
+            },
+        },
+    },
+    {
+        name: "token_get_ohlcv",
+        description: "Fetch OHLCV candles for a token and timeframe.",
+        inputSchema: {
+            type: "object",
+            required: ["mint", "timeframe"],
+            properties: {
+                mint: { type: "string" },
+                timeframe: { type: "string", description: "e.g. 1m, 5m, 1h, 1d" },
+                timeTo: { type: "number" },
+            },
+        },
+    },
+    {
+        name: "token_get_ohlcv_chart",
+        description: "Build a shareable chart URL from token OHLCV candles so agents can send an actual chart in chat (resolve ticker with token_search first).",
+        inputSchema: {
+            type: "object",
+            required: ["mint", "timeframe"],
+            properties: {
+                mint: { type: "string" },
+                timeframe: { type: "string", description: "e.g. 1m, 5m, 1h, 1d" },
+                timeTo: { type: "number" },
+                includeActive: { type: "boolean" },
+                maxPoints: { type: "number" },
+                width: { type: "number" },
+                height: { type: "number" },
+            },
+        },
+    },
+    {
+        name: "wallet_get_performance",
+        description: "Fetch wallet performance via Dritan.",
+        inputSchema: {
+            type: "object",
+            required: ["wallet"],
+            properties: {
+                wallet: { type: "string" },
+                showHistoricPnL: { type: "boolean" },
+                holdingCheck: { type: "boolean" },
+                hideDetails: { type: "boolean" },
+            },
+        },
+    },
+    {
+        name: "wallet_get_token_performance",
+        description: "Fetch wallet performance for a specific token mint via Dritan.",
+        inputSchema: {
+            type: "object",
+            required: ["wallet", "tokenMint"],
+            properties: {
+                wallet: { type: "string" },
+                tokenMint: { type: "string" },
+            },
+        },
+    },
+    {
+        name: "wallet_get_portfolio_chart",
+        description: "Fetch wallet portfolio chart series via Dritan.",
+        inputSchema: {
+            type: "object",
+            required: ["wallet"],
+            properties: {
+                wallet: { type: "string" },
+                days: { type: "number" },
+            },
+        },
+    },
+    {
+        name: "wallet_get_summary",
+        description: "Fetch basic wallet summary via Dritan.",
+        inputSchema: {
+            type: "object",
+            required: ["wallet"],
+            properties: {
+                wallet: { type: "string" },
+            },
+        },
+    },
+    {
+        name: "wallet_get_trade_history",
+        description: "Fetch wallet trade history via Dritan.",
+        inputSchema: {
+            type: "object",
+            required: ["wallet"],
+            properties: {
+                wallet: { type: "string" },
+                cursor: { type: "string" },
+            },
+        },
+    },
+    {
+        name: "wallet_get_holdings",
+        description: "Fetch wallet holdings via Dritan.",
+        inputSchema: {
+            type: "object",
+            required: ["wallet"],
+            properties: {
+                wallet: { type: "string" },
+            },
+        },
+    },
+    {
+        name: "wallet_get_holdings_page",
+        description: "Fetch paginated wallet holdings via Dritan.",
+        inputSchema: {
+            type: "object",
+            required: ["wallet", "page"],
+            properties: {
+                wallet: { type: "string" },
+                page: { type: "number" },
+            },
+        },
+    },
     {
         name: "market_stream_sample",
         description: "Open a DEX websocket stream and collect events for a short duration.",
@@ -231,13 +621,75 @@ const tools = [
             properties: {
                 dex: {
                     type: "string",
-                    enum: ["pumpamm", "pumpfun", "launchlab", "dlmm", "damm2", "damm1", "dbc"],
+                    enum: STREAM_DEXES,
                 },
                 durationMs: { type: "number" },
                 maxEvents: { type: "number" },
             },
         },
     },
+    {
+        name: "wallet_stream_sample",
+        description: "Open the wallet websocket stream and collect events for selected wallets.",
+        inputSchema: {
+            type: "object",
+            required: ["wallets"],
+            properties: {
+                wallets: { type: "array", items: { type: "string" } },
+                durationMs: { type: "number" },
+                maxEvents: { type: "number" },
+            },
+        },
+    },
+    {
+        name: "ths_health",
+        description: "Check Meteora THS service health.",
+        inputSchema: {
+            type: "object",
+            properties: {},
+        },
+    },
+    {
+        name: "ths_get_score",
+        description: "Fetch THS score for a wallet.",
+        inputSchema: {
+            type: "object",
+            required: ["wallet"],
+            properties: {
+                wallet: { type: "string" },
+                debug: { type: "boolean" },
+                breakdown: { type: "boolean" },
+            },
+        },
+    },
+    {
+        name: "ths_get_score_tokens_get",
+        description: "Fetch THS score for selected token mints using GET.",
+        inputSchema: {
+            type: "object",
+            required: ["wallet", "tokenMints"],
+            properties: {
+                wallet: { type: "string" },
+                tokenMints: { type: "array", items: { type: "string" } },
+                debug: { type: "boolean" },
+                breakdown: { type: "boolean" },
+            },
+        },
+    },
+    {
+        name: "ths_get_score_tokens_post",
+        description: "Fetch THS score for selected token mints using POST.",
+        inputSchema: {
+            type: "object",
+            required: ["wallet", "tokenMints"],
+            properties: {
+                wallet: { type: "string" },
+                tokenMints: { type: "array", items: { type: "string" } },
+                debug: { type: "boolean" },
+                breakdown: { type: "boolean" },
+            },
+        },
+    },
     {
         name: "swap_build",
         description: "Build an unsigned swap transaction with Dritan.",
@@ -297,14 +749,29 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         switch (request.params.name) {
             case "system_check_prereqs": {
                 const solanaCli = checkSolanaCli();
+                const apiKeySet = !!process.env.DRITAN_API_KEY;
                 return ok({
-                    ready: solanaCli.ok,
-                    checks: [solanaCli],
-                    nextAction: solanaCli.ok
-                        ? "Environment ready."
-                        : "Install Solana CLI using installHint, then retry wallet_create_local.",
+                    ready: solanaCli.ok && apiKeySet,
+                    checks: [
+                        solanaCli,
+                        {
+                            ok: apiKeySet,
+                            name: "DRITAN_API_KEY",
+                            hint: apiKeySet
+                                ? "API key is configured."
+                                : "Missing DRITAN_API_KEY. Get your key at https://dritan.dev and set it as an environment variable.",
+                        },
+                    ],
+                    nextAction: !apiKeySet
+                        ? "Set DRITAN_API_KEY environment variable. Get your key at https://dritan.dev"
+                        : !solanaCli.ok
+                            ? "Install Solana CLI using installHint, then retry wallet_create_local."
+                            : "Environment ready.",
                 });
             }
+            case "dritan_health": {
+                return ok(await checkDritanHealth());
+            }
             case "wallet_create_local": {
                 const input = walletCreateSchema.parse(args);
                 const walletPath = toWalletPath(input.name, input.walletDir);
@@ -343,6 +810,111 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     return ok(await client.getFirstBuyers(input.mint));
                 return ok(await client.getTokenAggregated(input.mint));
             }
+            case "token_get_price": {
+                const input = tokenMintSchema.parse(args);
+                const client = getDritanClient();
+                return ok(await client.getTokenPrice(input.mint));
+            }
+            case "token_search": {
+                const input = tokenSearchSchema.parse(args);
+                const client = getDritanClient();
+                return ok(await searchTokens(client, input.query, {
+                    limit: input.limit,
+                    cursor: input.cursor,
+                    page: input.page,
+                }));
+            }
+            case "token_get_metadata": {
+                const input = tokenMintSchema.parse(args);
+                const client = getDritanClient();
+                return ok(await client.getTokenMetadata(input.mint));
+            }
+            case "token_get_risk": {
+                const input = tokenMintSchema.parse(args);
+                const client = getDritanClient();
+                return ok(await client.getTokenRisk(input.mint));
+            }
+            case "token_get_first_buyers": {
+                const input = tokenMintSchema.parse(args);
+                const client = getDritanClient();
+                return ok(await client.getFirstBuyers(input.mint));
+            }
+            case "token_get_aggregated": {
+                const input = tokenMintSchema.parse(args);
+                const client = getDritanClient();
+                return ok(await client.getTokenAggregated(input.mint));
+            }
+            case "token_get_deployer_stats": {
+                const input = tokenMintSchema.parse(args);
+                const client = getDritanClient();
+                return ok(await client.getDeployerStats(input.mint));
+            }
+            case "token_get_ohlcv": {
+                const input = tokenOhlcvSchema.parse(args);
+                const client = getDritanClient();
+                return ok(await client.getTokenOhlcv(input.mint, input.timeframe, { timeTo: input.timeTo }));
+            }
+            case "token_get_ohlcv_chart": {
+                const input = tokenOhlcvChartSchema.parse(args);
+                const client = getDritanClient();
+                const ohlcv = await client.getTokenOhlcv(input.mint, input.timeframe, { timeTo: input.timeTo });
+                const bars = [...(ohlcv.closed ?? [])];
+                if (input.includeActive && ohlcv.active) {
+                    bars.push(ohlcv.active);
+                }
+                const trimmedBars = bars.slice(-input.maxPoints);
+                if (trimmedBars.length === 0) {
+                    throw new Error(`No OHLCV data available for ${input.mint} (${input.timeframe})`);
+                }
+                const chartUrl = buildOhlcvChartUrl(input.mint, input.timeframe, trimmedBars, input.width, input.height);
+                return ok({
+                    mint: input.mint,
+                    timeframe: input.timeframe,
+                    points: trimmedBars.length,
+                    chartUrl,
+                    markdown: `![${input.mint} ${input.timeframe} chart](${chartUrl})`,
+                    lastBar: trimmedBars[trimmedBars.length - 1],
+                });
+            }
+            case "wallet_get_performance": {
+                const input = walletPerformanceSchema.parse(args);
+                const client = getDritanClient();
+                return ok(await client.getWalletPerformance(input.wallet, {
+                    showHistoricPnL: input.showHistoricPnL,
+                    holdingCheck: input.holdingCheck,
+                    hideDetails: input.hideDetails,
+                }));
+            }
+            case "wallet_get_token_performance": {
+                const input = walletTokenPerformanceSchema.parse(args);
+                const client = getDritanClient();
+                return ok(await client.getWalletTokenPerformance(input.wallet, input.tokenMint));
+            }
+            case "wallet_get_portfolio_chart": {
+                const input = walletPortfolioChartSchema.parse(args);
+                const client = getDritanClient();
+                return ok(await client.getWalletPortfolioChart(input.wallet, { days: input.days }));
+            }
+            case "wallet_get_summary": {
+                const input = walletAddressSchema.parse(args);
+                const client = getDritanClient();
+                return ok(await client.getBasicWalletInformation(input.wallet));
+            }
+            case "wallet_get_trade_history": {
+                const input = walletTradeHistorySchema.parse(args);
+                const client = getDritanClient();
+                return ok(await client.getWalletTradeHistory(input.wallet, { cursor: input.cursor }));
+            }
+            case "wallet_get_holdings": {
+                const input = walletAddressSchema.parse(args);
+                const client = getDritanClient();
+                return ok(await client.getWalletHoldings(input.wallet));
+            }
+            case "wallet_get_holdings_page": {
+                const input = walletHoldingsPageSchema.parse(args);
+                const client = getDritanClient();
+                return ok(await client.getWalletHoldingsPage(input.wallet, input.page));
+            }
             case "market_stream_sample": {
                 const input = marketStreamSampleSchema.parse(args);
                 const client = getDritanClient();
@@ -374,6 +946,80 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 await done;
                 return ok({ dex: input.dex, opened, closed, eventsCaptured: events.length, sample: events });
             }
+            case "wallet_stream_sample": {
+                const input = walletStreamSampleSchema.parse(args);
+                const client = getDritanClient();
+                const events = [];
+                let opened = false;
+                let closed = false;
+                const done = new Promise((resolvePromise) => {
+                    const handle = client.streamDex("wallet-stream", {
+                        onOpen: () => {
+                            opened = true;
+                            try {
+                                handle.socket.send(JSON.stringify({
+                                    method: "subscribeWallets",
+                                    wallets: input.wallets,
+                                }));
+                            }
+                            catch {
+                                // no-op
+                            }
+                        },
+                        onClose: () => {
+                            closed = true;
+                            resolvePromise();
+                        },
+                        onMessage: (event) => {
+                            events.push(event);
+                            if (events.length >= input.maxEvents) {
+                                handle.close();
+                            }
+                        },
+                    });
+                    setTimeout(() => {
+                        if (!closed) {
+                            handle.close();
+                        }
+                    }, input.durationMs);
+                });
+                await done;
+                return ok({
+                    wallets: input.wallets,
+                    opened,
+                    closed,
+                    eventsCaptured: events.length,
+                    sample: events,
+                });
+            }
+            case "ths_health": {
+                const ths = getThsClient();
+                return ok({ ok: await ths.health() });
+            }
+            case "ths_get_score": {
+                const input = thsScoreSchema.parse(args);
+                const ths = getThsClient();
+                return ok(await ths.getThsScore(input.wallet, {
+                    debug: input.debug,
+                    breakdown: input.breakdown,
+                }));
+            }
+            case "ths_get_score_tokens_get": {
+                const input = thsScoreTokensSchema.parse(args);
+                const ths = getThsClient();
+                return ok(await ths.getThsScoreForTokens(input.wallet, input.tokenMints, {
+                    debug: input.debug,
+                    breakdown: input.breakdown,
+                }));
+            }
+            case "ths_get_score_tokens_post": {
+                const input = thsScoreTokensSchema.parse(args);
+                const ths = getThsClient();
+                return ok(await ths.postThsScoreForTokens(input.wallet, input.tokenMints, {
+                    debug: input.debug,
+                    breakdown: input.breakdown,
+                }));
+            }
             case "swap_build": {
                 const input = swapBuildSchema.parse(args);
                 const client = getDritanClient();

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@dritan/mcp",
-  "version": "0.1.1",
+  "version": "0.3.0",
   "license": "MIT",
   "type": "module",
   "description": "MCP server for Dritan SDK market data and local Solana wallet swap execution",
   "repository": {
     "type": "git",
-    "url": "https://github.com/dritan/dritan"
+    "url": "https://github.com/amirdauti/dritan-mcp"
   },
   "homepage": "https://dritan.dev",
   "bugs": {
@@ -25,7 +25,8 @@
     "build": "tsc -p tsconfig.json",
     "dev": "tsx src/index.ts",
     "start": "node dist/index.js",
-    "lint": "tsc -p tsconfig.json --noEmit"
+    "lint": "tsc -p tsconfig.json --noEmit",
+    "release": "semantic-release"
   },
   "publishConfig": {
     "access": "public"
@@ -33,11 +34,20 @@
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.17.4",
     "@solana/web3.js": "^1.98.4",
-    "dritan-sdk": "^0.1.1",
+    "dritan-sdk": "^0.6.0",
     "zod": "^3.24.1"
   },
   "devDependencies": {
+    "@semantic-release/changelog": "^6.0.3",
+    "@semantic-release/commit-analyzer": "^13.0.1",
+    "@semantic-release/exec": "^7.1.0",
+    "@semantic-release/git": "^10.0.1",
+    "@semantic-release/github": "^11.0.6",
+    "@semantic-release/npm": "^12.0.2",
+    "@semantic-release/release-notes-generator": "^14.1.0",
     "@types/node": "^22.14.0",
+    "conventional-changelog-conventionalcommits": "^9.1.0",
+    "semantic-release": "^24.2.9",
     "tsx": "^4.19.2",
     "typescript": "^5.8.2"
   }