m2m-sentinel-sdk 1.0.2 → 1.0.4

package/README.md

@@ -1,43 +1,59 @@
-# m2m-sentinel-sdk
+# M2M Sentinel SDKs
 
-> Official Client SDK for M2M Sentinel: Autonomous Machine-to-Machine Web3 Security & AI Intelligence Engine.
+Base URL: `https://m2msentinel.vercel.app`.
 
-[![npm version](https://img.shields.io/npm/v/m2m-sentinel-sdk.svg)](https://www.npmjs.com/package/m2m-sentinel-sdk)
-[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+## Support status
+
+Supported in this repository:
+- JavaScript/Node: `public/sdk/index.js` (`m2m_sentinel_sdk.js` re-exports it)
+- TypeScript source: `public/sdk/typescript/index.ts`
+- Python source: `public/sdk/m2m_sentinel/` and `public/sdk/python/m2m_sentinel/`
+- MCP stdio server: `public/sdk/mcp_server.js`
+
+Community preview only: Go, Rust, Java, Kotlin, Swift, C#, PHP, Ruby, CLI, Eliza plugin, and agent adapter. They include current route/header examples but are not covered by the supported-SDK guarantee; verify against `/openapi.json` before production use.
 
 ## Installation
 
+Install from source (recommended for current `v1.0.4` build):
+
 ```bash
-npm install m2m-sentinel-sdk
+# JavaScript / Node.js (local path)
+node -e "const { M2MSentinelClient } = require('./public/sdk')"
+
+# Python (local path)
+python -m pip install ./public/sdk/python
 ```
 
-## Quickstart
+*Note on Registry Packages (`v1.0.4`)*:
+Once published to npm and PyPI (via `npm publish` and `twine upload`), install directly via the package manager:
+- **npm registry**: `m2m-sentinel-sdk`
+- **PyPI registry**: `m2m-sentinel`
 
-```javascript
-const { M2MSentinelClient } = require('m2m-sentinel-sdk');
+## Authentication
 
-const client = new M2MSentinelClient();
+API keys must be sent only in headers:
 
-async function run() {
-  // Audit a Smart Contract
-  const audit = await client.auditContract('0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913');
-  console.log('Contract Risk Audit:', audit);
+```text
+x-api-key: <key>
+```
 
-  // Fetch Real-Time Whale Transfer Alerts
-  const whales = await client.getWhaleSignals();
-  console.log('Whale Signals:', whales);
-}
+`Authorization: Bearer <key>` is accepted by the API, but the supported SDKs use `x-api-key`. Never place credentials in URLs or query strings; the server rejects them with HTTP 401.
 
-run();
-```
+## x402 / 402 behavior
+
+Paid endpoints accept either `x-api-key` or a settled x402 v2 payment. Without credentials they return HTTP 402 and a `PAYMENT-REQUIRED` header containing a JSON challenge. Supported SDKs raise/return a payment-required error that exposes the parsed challenge. After settlement, retry with `PAYMENT-SIGNATURE`; successful paid responses may include `PAYMENT-RESPONSE` and include `provenance` in the JSON body.
+
+## Free-tier signup
+
+1. `POST /v1/subscribe/free/challenge` with `{ "userWallet": "0x..." }`.
+2. Sign `intent.messageToSign` with that wallet.
+3. `POST /v1/subscribe/free/claim` with `{ "intentId": "...", "signature": "..." }`.
+4. Store the returned `apiKey`; it cannot be recovered later.
+
+## Current routes
+
+Public: `GET /v1/status`, `GET /v1/plans`, free signup, and subscription intent/claim routes.
 
-## Features
-- **Smart Contract Risk Auditor** (`/v1/audit/:address`)
-- **Real-Time Whale Signals** (`/v1/whales/signals`)
-- **DEX Liquidity Depth & Spreads** (`/v1/dex/metrics`)
-- **AI Web Search Intelligence** (`/v1/search`)
+Protected/paid: `GET /v1/audit/:address`, `GET /v1/security/score/:address`, `GET /v1/gas/fees`, `GET /v1/dex/metrics`, `GET /v1/token/price/:symbol`, `GET /v1/whales/signals`, `GET /v1/keys/self`, `POST /v1/keys/revoke`.
 
-## Documentation & Portals
-- **Live Portal**: [https://m2msentinel.vercel.app](https://m2msentinel.vercel.app)
-- **API Docs**: [https://m2msentinel.vercel.app/docs.html](https://m2msentinel.vercel.app/docs.html)
-- **OpenAPI Spec**: [https://m2msentinel.vercel.app/openapi.json](https://m2msentinel.vercel.app/openapi.json)
+SDKs preserve response bodies, including `provenance`. They surface 401, 402, 405, 429 (`Retry-After`), and 503 `DATA_SOURCE_UNAVAILABLE` without inventing fallback values.

package/agent_adapter.js

@@ -0,0 +1,30 @@
+// UNSUPPORTED / COMMUNITY PREVIEW — not covered by the supported-SDK guarantee; verify against /openapi.json before production use.
+
+const { M2MSentinelClient } = require('./index.js');
+
+class M2MSentinelAgentTool {
+  constructor(options = {}) {
+    this.name = 'm2m_sentinel_security_audit';
+    this.description = 'Audits EVM smart contracts on Base for security risks, proxies, and bytecode findings.';
+    this.client = new M2MSentinelClient({
+      apiKey: options.apiKey || process.env.M2M_SENTINEL_API_KEY,
+      baseUrl: options.baseUrl
+    });
+  }
+
+  async _call(address) {
+    try {
+      return await this.client.auditContract(address);
+    } catch (err) {
+      return {
+        error: err.name || 'M2MSentinelError',
+        message: err.message,
+        status: err.status,
+        paymentRequired: err.paymentRequired || null,
+        retryAfter: err.retryAfter || null
+      };
+    }
+  }
+}
+
+module.exports = { M2MSentinelAgentTool };

package/eliza_plugin.js

@@ -0,0 +1,84 @@
+// UNSUPPORTED / COMMUNITY PREVIEW — not covered by the supported-SDK guarantee; verify against /openapi.json before production use.
+
+const { M2MSentinelClient } = require('./index.js');
+
+function clientFor(runtime) {
+  const apiKey = runtime?.getSetting?.('M2M_SENTINEL_API_KEY') || process.env.M2M_SENTINEL_API_KEY;
+  return new M2MSentinelClient({ apiKey });
+}
+
+function errorText(err) {
+  if (err.status === 402) return 'M2M Sentinel payment required. Configure M2M_SENTINEL_API_KEY or settle the x402 challenge.';
+  if (err.status === 503 && err.body?.error === 'DATA_SOURCE_UNAVAILABLE') return 'M2M Sentinel data source unavailable; no estimated fallback value is returned.';
+  if (err.status === 429) return 'M2M Sentinel rate limited. Retry-After: ' + (err.retryAfter || 'not provided');
+  return 'M2M Sentinel API request failed: ' + err.message;
+}
+
+const m2mSentinelPlugin = {
+  name: '@elizaos/plugin-m2m-sentinel',
+  description: 'Preview ElizaOS actions for M2M Sentinel protected Web3 API routes.',
+  actions: [
+    {
+      name: 'AUDIT_CONTRACT',
+      description: 'Audits an EVM contract on Base Mainnet.',
+      handler: async (runtime, message) => {
+        const address = message.content.text.match(/0x[a-fA-F0-9]{40}/)?.[0];
+        if (!address) return { text: 'Please provide a valid 42-character EVM contract address.' };
+        try {
+          const data = await clientFor(runtime).auditContract(address);
+          const audit = data.audit || {};
+          const proxy = audit.proxyResolution || {};
+          return { text: `M2M Sentinel audit for ${address}: ${audit.securityRating || 'UNKNOWN'}; proxy=${proxy.isProxy ? proxy.proxyType : 'NO'}; provenance=${JSON.stringify(audit.provenance || data.provenance || null)}` };
+        } catch (err) { return { text: errorText(err) }; }
+      }
+    },
+    {
+      name: 'GET_SECURITY_SCORE',
+      description: 'Returns the security score for a Base contract address.',
+      handler: async (runtime, message) => {
+        const address = message.content.text.match(/0x[a-fA-F0-9]{40}/)?.[0];
+        if (!address) return { text: 'Please provide a valid EVM contract address.' };
+        try {
+          const data = await clientFor(runtime).getSecurityScore(address);
+          const score = data.securityScore === null ? 'not decision-grade' : `${data.securityScore}/100`;
+          return { text: `M2M Sentinel security score for ${address}: ${score}. Provenance: ${JSON.stringify(data.provenance || null)}` };
+        } catch (err) { return { text: errorText(err) }; }
+      }
+    },
+    {
+      name: 'GET_DEX_METRICS',
+      description: 'Fetches Base DEX metrics.',
+      handler: async (runtime) => {
+        try { return { text: JSON.stringify(await clientFor(runtime).getDexMetrics()) }; }
+        catch (err) { return { text: errorText(err) }; }
+      }
+    },
+    {
+      name: 'GET_TOKEN_PRICE',
+      description: 'Queries a tracked Base token price.',
+      handler: async (runtime, message) => {
+        const symbol = (message.content.text.match(/price of ([a-zA-Z0-9]+)/i)?.[1] || 'USDC').toUpperCase();
+        try { return { text: JSON.stringify(await clientFor(runtime).getTokenPrice(symbol)) }; }
+        catch (err) { return { text: errorText(err) }; }
+      }
+    },
+    {
+      name: 'GET_GAS_FEES',
+      description: 'Fetches live Base gas fees.',
+      handler: async (runtime) => {
+        try { return { text: JSON.stringify(await clientFor(runtime).getGasFees()) }; }
+        catch (err) { return { text: errorText(err) }; }
+      }
+    },
+    {
+      name: 'GET_WHALE_SIGNALS',
+      description: 'Fetches whale signals.',
+      handler: async (runtime) => {
+        try { return { text: JSON.stringify(await clientFor(runtime).getWhaleSignals()) }; }
+        catch (err) { return { text: errorText(err) }; }
+      }
+    }
+  ]
+};
+
+module.exports = { m2mSentinelPlugin };

package/index.js

@@ -1,26 +1,143 @@
-const axios = require('axios');
+const DEFAULT_BASE_URL = 'https://m2msentinel.vercel.app';
+const DEFAULT_TIMEOUT_MS = 30000;
+
+class M2MSentinelError extends Error {
+  constructor(message, options = {}) {
+    super(message);
+    this.name = this.constructor.name;
+    this.status = options.status;
+    this.body = options.body;
+    this.retryAfter = options.retryAfter || null;
+    this.paymentRequired = options.paymentRequired || null;
+    this.paymentResponse = options.paymentResponse || null;
+  }
+}
+
+class PaymentRequiredError extends M2MSentinelError {}
+class RateLimitedError extends M2MSentinelError {}
+class DataSourceUnavailableError extends M2MSentinelError {}
+
+function parseHeaderJson(value) {
+  if (!value) return null;
+  try { return JSON.parse(value); } catch (_) { return null; }
+}
+
+function normalizeOptions(optionsOrApiKey, baseUrl) {
+  if (optionsOrApiKey && typeof optionsOrApiKey === 'object') return { ...optionsOrApiKey };
+  return { apiKey: optionsOrApiKey || undefined, baseUrl: baseUrl || DEFAULT_BASE_URL };
+}
 
 class M2MSentinelClient {
-    constructor(apiKey, baseUrl = 'https://m2msentinel.vercel.app') {
-        this.apiKey = apiKey;
-        this.baseUrl = baseUrl.replace(/\/+$/, '');
-        this.client = axios.create({
-            baseURL: this.baseUrl,
-            headers: {
-                'Authorization': `Bearer ${this.apiKey}`,
-                'Content-Type': 'application/json'
-            }
-        });
+  constructor(optionsOrApiKey, baseUrl) {
+    const options = normalizeOptions(optionsOrApiKey, baseUrl);
+    this.baseUrl = (options.baseUrl || DEFAULT_BASE_URL).replace(/\/+$/, '');
+    this.apiKey = options.apiKey || undefined;
+    this.timeoutMs = options.timeoutMs || DEFAULT_TIMEOUT_MS;
+    this.paymentSignature = options.paymentSignature || undefined;
+  }
+
+  async request(method, path, body, options = {}) {
+    const headers = {
+      'Accept': 'application/json'
+    };
+    if (body !== undefined) headers['Content-Type'] = 'application/json';
+    const apiKey = options.apiKey || this.apiKey;
+    if (apiKey) headers['x-api-key'] = apiKey;
+    const paymentSignature = options.paymentSignature || this.paymentSignature;
+    if (paymentSignature) headers['PAYMENT-SIGNATURE'] = paymentSignature;
+
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), options.timeoutMs || this.timeoutMs);
+    let response;
+    try {
+      response = await fetch(this.baseUrl + path, {
+        method,
+        headers,
+        body: body === undefined ? undefined : JSON.stringify(body),
+        signal: controller.signal
+      });
+    } catch (err) {
+      if (err && err.name === 'AbortError') throw new M2MSentinelError('M2M Sentinel request timed out', { status: 0 });
+      throw err;
+    } finally {
+      clearTimeout(timeout);
     }
 
-    async getStatus() {
-        try {
-            const response = await this.client.get('/v1/status');
-            return response.data;
-        } catch (error) {
-            throw error;
-        }
+    const text = await response.text();
+    let data = null;
+    if (text) {
+      try { data = JSON.parse(text); } catch (_) { data = { raw: text }; }
+    }
+
+    const paymentRequired = parseHeaderJson(response.headers.get('PAYMENT-REQUIRED'));
+    const paymentResponse = parseHeaderJson(response.headers.get('PAYMENT-RESPONSE')) || response.headers.get('PAYMENT-RESPONSE');
+    if (response.ok) return data;
+
+    const details = {
+      status: response.status,
+      body: data,
+      retryAfter: response.headers.get('Retry-After'),
+      paymentRequired,
+      paymentResponse
+    };
+    const message = data && data.message ? data.message : 'M2M Sentinel HTTP ' + response.status;
+    if (response.status === 402) throw new PaymentRequiredError(message, details);
+    if (response.status === 429) throw new RateLimitedError(message, details);
+    if (response.status === 503 && data && data.error === 'DATA_SOURCE_UNAVAILABLE') throw new DataSourceUnavailableError(message, details);
+    throw new M2MSentinelError(message, details);
+  }
+
+  getStatus() { return this.request('GET', '/v1/status'); }
+  getPlans() { return this.request('GET', '/v1/plans'); }
+  createFreeChallenge(userWallet) { return this.request('POST', '/v1/subscribe/free/challenge', { userWallet }); }
+  claimFreeTier(intentId, signature) { return this.request('POST', '/v1/subscribe/free/claim', { intentId, signature }); }
+  createSubscriptionIntent(tier, userWallet) { return this.request('POST', '/v1/subscribe/intents', { tier, userWallet }); }
+  claimSubscription(intentId, signature, txHash) { return this.request('POST', '/v1/subscribe/crypto', { intentId, signature, txHash }); }
+  auditContract(address, options) { return this.request('GET', '/v1/audit/' + encodeURIComponent(address), undefined, options); }
+  getSecurityScore(address, options) { return this.request('GET', '/v1/security/score/' + encodeURIComponent(address), undefined, options); }
+  getGasFees(options) { return this.request('GET', '/v1/gas/fees', undefined, options); }
+  getDexMetrics(options) { return this.request('GET', '/v1/dex/metrics', undefined, options); }
+  getTokenPrice(symbol, options) { return this.request('GET', '/v1/token/price/' + encodeURIComponent(symbol), undefined, options); }
+  getWhaleSignals(options) { return this.request('GET', '/v1/whales/signals', undefined, options); }
+  getKeySelf() { return this.request('GET', '/v1/keys/self'); }
+  revokeKey(confirm = true) { return this.request('POST', '/v1/keys/revoke', { confirm }); }
+}
+
+function createEthersSentinelMiddleware(apiKey, baseUrl) {
+  const client = new M2MSentinelClient({ apiKey, baseUrl });
+  return {
+    client,
+    verifyContractBeforeTx: async (targetAddress) => {
+      const audit = await client.auditContract(targetAddress);
+      const verdict = audit && audit.audit && audit.audit.verdict;
+      if (verdict && verdict.securityRating === 'HIGH_RISK') {
+        throw new Error('[M2M Sentinel] Transaction blocked: ' + targetAddress + ' flagged HIGH_RISK.');
+      }
+      return audit;
+    }
+  };
+}
+
+function createViemSentinelInterceptor(apiKey, baseUrl) {
+  const client = new M2MSentinelClient({ apiKey, baseUrl });
+  return {
+    client,
+    inspectSwapTarget: async (address) => {
+      const score = await client.getSecurityScore(address);
+      if (score && score.decisionGrade && typeof score.securityScore === 'number' && score.securityScore < 50) {
+        throw new Error('[M2M Sentinel] Security score too low (' + score.securityScore + '/100) for ' + address);
+      }
+      return score;
     }
+  };
 }
 
-module.exports = { M2MSentinelClient };
+module.exports = {
+  M2MSentinelClient,
+  M2MSentinelError,
+  PaymentRequiredError,
+  RateLimitedError,
+  DataSourceUnavailableError,
+  createEthersSentinelMiddleware,
+  createViemSentinelInterceptor
+};

package/m2m_sentinel_sdk.js

@@ -1,12 +1 @@
-class M2MSentinelSDK {
-    constructor(apiKey) {
-        this.apiKey = apiKey;
-        this.baseUrl = 'https://m2msentinel.vercel.app/v1';
-    }
-
-    async getTokenPrice() {
-        const response = await fetch(`${this.baseUrl}/token/price`);
-        return response.json();
-    }
-}
-module.exports = M2MSentinelSDK;
+module.exports = require('./index.js');

package/mcp_server.js

@@ -0,0 +1,172 @@
+#!/usr/bin/env node
+'use strict';
+
+const https = require('https');
+const readline = require('readline');
+
+const BASE_URL = process.env.M2M_SENTINEL_BASE_URL || 'https://m2msentinel.vercel.app';
+const API_KEY = process.env.M2M_SENTINEL_API_KEY || '';
+const TIMEOUT_MS = Number(process.env.M2M_SENTINEL_TIMEOUT_MS || 30000);
+
+const TOOLS = [
+  {
+    name: 'audit_contract',
+    description: 'Audit an EVM smart contract address on Base and return bytecode findings, verdict, score, and provenance.',
+    inputSchema: { type: 'object', properties: { address: { type: 'string' } }, required: ['address'] }
+  },
+  {
+    name: 'get_security_score',
+    description: 'Return the M2M Sentinel security score and provenance for a Base contract address.',
+    inputSchema: { type: 'object', properties: { address: { type: 'string' } }, required: ['address'] }
+  },
+  {
+    name: 'get_gas_fees',
+    description: 'Return current Base gas fee data and provenance.',
+    inputSchema: { type: 'object', properties: {} }
+  },
+  {
+    name: 'get_dex_metrics',
+    description: 'Return tracked Base DEX metrics and provenance.',
+    inputSchema: { type: 'object', properties: {} }
+  },
+  {
+    name: 'get_token_price',
+    description: 'Return tracked Base token price data and provenance for a symbol such as USDC or WETH.',
+    inputSchema: { type: 'object', properties: { symbol: { type: 'string' } }, required: ['symbol'] }
+  },
+  {
+    name: 'get_whale_signals',
+    description: 'Return tracked Base whale signals and provenance.',
+    inputSchema: { type: 'object', properties: {} }
+  }
+];
+
+function parseHeaderJson(value) {
+  if (!value) return null;
+  try { return JSON.parse(value); } catch (_) { return null; }
+}
+
+function queryApi(path) {
+  return new Promise((resolve, reject) => {
+    const url = new URL(path, BASE_URL);
+    const headers = { Accept: 'application/json', 'User-Agent': 'M2MSentinel-MCP/1.0.4' };
+    if (API_KEY) headers['x-api-key'] = API_KEY;
+
+    const req = https.request(url, { method: 'GET', headers, timeout: TIMEOUT_MS }, (res) => {
+      let data = '';
+      res.setEncoding('utf8');
+      res.on('data', (chunk) => { data += chunk; });
+      res.on('end', () => {
+        let body = null;
+        if (data) {
+          try { body = JSON.parse(data); } catch (_) { body = { raw: data }; }
+        }
+        resolve({
+          status: res.statusCode,
+          ok: res.statusCode >= 200 && res.statusCode < 300,
+          body,
+          paymentRequired: parseHeaderJson(res.headers['payment-required']),
+          paymentResponse: parseHeaderJson(res.headers['payment-response']) || res.headers['payment-response'] || null,
+          retryAfter: res.headers['retry-after'] || null
+        });
+      });
+    });
+    req.on('timeout', () => req.destroy(new Error('M2M Sentinel request timed out')));
+    req.on('error', reject);
+    req.end();
+  });
+}
+
+function pathForTool(name, args) {
+  const input = args || {};
+  switch (name) {
+    case 'audit_contract':
+      if (!input.address) throw new Error('address is required');
+      return '/v1/audit/' + encodeURIComponent(input.address);
+    case 'get_security_score':
+      if (!input.address) throw new Error('address is required');
+      return '/v1/security/score/' + encodeURIComponent(input.address);
+    case 'get_gas_fees':
+      return '/v1/gas/fees';
+    case 'get_dex_metrics':
+      return '/v1/dex/metrics';
+    case 'get_token_price':
+      if (!input.symbol) throw new Error('symbol is required');
+      return '/v1/token/price/' + encodeURIComponent(input.symbol);
+    case 'get_whale_signals':
+      return '/v1/whales/signals';
+    default:
+      throw new Error('Unknown tool: ' + name);
+  }
+}
+
+function send(message) {
+  process.stdout.write(JSON.stringify(message) + '\n');
+}
+
+function success(id, result) {
+  send({ jsonrpc: '2.0', id, result });
+}
+
+function failure(id, code, message, data) {
+  const error = { code, message };
+  if (data !== undefined) error.data = data;
+  send({ jsonrpc: '2.0', id, error });
+}
+
+async function handle(request) {
+  if (!request || request.jsonrpc !== '2.0' || typeof request.method !== 'string') {
+    failure(request && request.id !== undefined ? request.id : null, -32600, 'Invalid Request');
+    return;
+  }
+  if (request.id === undefined || request.id === null) return;
+
+  try {
+    if (request.method === 'initialize') {
+      success(request.id, {
+        protocolVersion: request.params && request.params.protocolVersion ? request.params.protocolVersion : '2024-11-05',
+        capabilities: { tools: {} },
+        serverInfo: { name: 'm2m-sentinel-mcp', version: '1.0.4' }
+      });
+      return;
+    }
+    if (request.method === 'tools/list') {
+      success(request.id, { tools: TOOLS });
+      return;
+    }
+    if (request.method === 'tools/call') {
+      const params = request.params || {};
+      const path = pathForTool(params.name, params.arguments || {});
+      const apiResult = await queryApi(path);
+      const isError = !apiResult.ok;
+      success(request.id, {
+        content: [{ type: 'text', text: JSON.stringify(apiResult.body, null, 2) }],
+        isError,
+        structuredContent: apiResult.body,
+        _meta: {
+          httpStatus: apiResult.status,
+          paymentRequired: apiResult.paymentRequired,
+          paymentResponse: apiResult.paymentResponse,
+          retryAfter: apiResult.retryAfter
+        }
+      });
+      return;
+    }
+    failure(request.id, -32601, 'Method not found');
+  } catch (err) {
+    failure(request.id, -32603, err && err.message ? err.message : 'Internal error');
+  }
+}
+
+const rl = readline.createInterface({ input: process.stdin, crlfDelay: Infinity });
+rl.on('line', (line) => {
+  if (!line.trim()) return;
+  let request;
+  try {
+    request = JSON.parse(line);
+  } catch (err) {
+    failure(null, -32700, 'Parse error');
+    return;
+  }
+  handle(request);
+});

package/package.json

@@ -1,19 +1,36 @@
 {
   "name": "m2m-sentinel-sdk",
-  "version": "1.0.2",
-  "description": "Official Client SDK for M2M Sentinel Web3 Security Risk Auditor & AI Intelligence Engine",
+  "version": "1.0.4",
+  "description": "JavaScript/Node.js client SDK for M2M Sentinel Web3 Pre-Transaction Risk Decision API",
   "main": "index.js",
-  "scripts": {
-    "test": "node index.js"
+  "types": "typescript/index.d.ts",
+  "license": "MIT",
+  "homepage": "https://m2msentinel.vercel.app",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/m2msentinel/m2m-sentinel"
+  },
+  "bugs": {
+    "url": "https://m2msentinel.vercel.app/docs.html"
   },
   "keywords": [
     "web3",
-    "ai-agent",
+    "x402",
+    "m2m-sentinel",
+    "base",
+    "risk-api",
     "smart-contract-audit",
-    "crypto-api",
-    "m2m",
-    "sentinel"
+    "agents"
   ],
   "author": "M2M Sentinel",
-  "license": "MIT"
+  "files": [
+    "index.js",
+    "m2m_sentinel_sdk.js",
+    "agent_adapter.js",
+    "eliza_plugin.js",
+    "mcp_server.js",
+    "README.md",
+    "typescript/"
+  ]
 }
+