@scriptmasterlabs/mcp-x402 2.0.2 → 2.1.0

package/src/lib/chains/base.ts

@@ -1,77 +0,0 @@
-import { createWalletClient, createPublicClient, http, parseUnits } from 'viem';
-import { base, baseSepolia } from 'viem/chains';
-import { privateKeyToAccount } from 'viem/accounts';
-import { mnemonicToSeedSync } from 'bip39';
-import HDKey from 'hdkey';
-import { WalletManager } from '../../server/payments/wallet.js';
-import type { RouteParams } from '../../server/payments/router.js';
-
-// USDC contract on Base mainnet
-const USDC_BASE = '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913';
-// USDC contract on Base Sepolia
-const USDC_BASE_SEPOLIA = '0x036CbD53842c5426634e7929541eC2318f3dCF7e';
-
-const ERC20_TRANSFER_ABI = [
-  {
-    name: 'transfer',
-    type: 'function',
-    inputs: [
-      { name: 'to', type: 'address' },
-      { name: 'amount', type: 'uint256' },
-    ],
-    outputs: [{ name: '', type: 'bool' }],
-    stateMutability: 'nonpayable',
-  },
-] as const;
-
-export class BaseChain {
-  private static instance: BaseChain;
-  private readonly testnet: boolean;
-
-  private constructor() {
-    this.testnet = process.env['TESTNET'] === 'true';
-  }
-
-  static getInstance(): BaseChain {
-    if (!BaseChain.instance) {
-      BaseChain.instance = new BaseChain();
-    }
-    return BaseChain.instance;
-  }
-
-  async sendPayment(params: RouteParams): Promise<string> {
-    const chain = this.testnet ? baseSepolia : base;
-    const rpcUrl = this.testnet
-      ? (process.env['BASE_SEPOLIA_RPC_URL'] ?? 'https://sepolia.base.org')
-      : (process.env['BASE_RPC_URL'] ?? 'https://mainnet.base.org');
-
-    const privateKey = await this.getPrivateKey();
-    const account = privateKeyToAccount(privateKey);
-
-    const walletClient = createWalletClient({ account, chain, transport: http(rpcUrl) });
-    const publicClient = createPublicClient({ chain, transport: http(rpcUrl) });
-
-    const usdcAddress = this.testnet ? USDC_BASE_SEPOLIA : USDC_BASE;
-    const amount = parseUnits(params.amount, 6); // USDC has 6 decimals
-
-    const hash = await walletClient.writeContract({
-      address: usdcAddress,
-      abi: ERC20_TRANSFER_ABI,
-      functionName: 'transfer',
-      args: [params.to as `0x${string}`, amount],
-    });
-
-    // Wait for confirmation
-    await publicClient.waitForTransactionReceipt({ hash });
-    return hash;
-  }
-
-  private async getPrivateKey(): Promise<`0x${string}`> {
-    const mnemonic = await WalletManager.getInstance().getSeed();
-    const seed = mnemonicToSeedSync(mnemonic);
-    const hdkey = HDKey.fromMasterSeed(seed);
-    const child = hdkey.derive("m/44'/60'/0'/0/0");
-    if (!child.privateKey) throw new Error('Key derivation failed');
-    return `0x${child.privateKey.toString('hex')}`;
-  }
-}

package/src/lib/chains/solana.ts

@@ -1,59 +0,0 @@
-import {
-  Connection,
-  Keypair,
-  PublicKey,
-  Transaction,
-  sendAndConfirmTransaction,
-} from '@solana/web3.js';
-import { createTransferInstruction, getAssociatedTokenAddress } from '@solana/spl-token';
-import { mnemonicToSeedSync } from 'bip39';
-import HDKey from 'hdkey';
-import { WalletManager } from '../../server/payments/wallet.js';
-import type { RouteParams } from '../../server/payments/router.js';
-
-// USDC mint on Solana mainnet
-const USDC_MINT = new PublicKey('EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v');
-
-export class SolanaChain {
-  private static instance: SolanaChain;
-  private readonly rpcUrl: string;
-
-  private constructor() {
-    this.rpcUrl = process.env['SOLANA_RPC_URL'] ?? 'https://api.mainnet-beta.solana.com';
-  }
-
-  static getInstance(): SolanaChain {
-    if (!SolanaChain.instance) {
-      SolanaChain.instance = new SolanaChain();
-    }
-    return SolanaChain.instance;
-  }
-
-  async sendPayment(params: RouteParams): Promise<string> {
-    const connection = new Connection(this.rpcUrl, 'confirmed');
-    const payer = await this.getKeypair();
-    const destination = new PublicKey(params.to);
-
-    const fromATA = await getAssociatedTokenAddress(USDC_MINT, payer.publicKey);
-    const toATA = await getAssociatedTokenAddress(USDC_MINT, destination);
-
-    const lamports = Math.round(parseFloat(params.amount) * 1_000_000); // USDC 6 decimals
-
-    const tx = new Transaction().add(
-      createTransferInstruction(fromATA, toATA, payer.publicKey, BigInt(lamports)),
-    );
-
-    const sig = await sendAndConfirmTransaction(connection, tx, [payer]);
-    return sig;
-  }
-
-  private async getKeypair(): Promise<Keypair> {
-    const mnemonic = await WalletManager.getInstance().getSeed();
-    const seed = mnemonicToSeedSync(mnemonic);
-    const hdkey = HDKey.fromMasterSeed(seed);
-    // BIP-44 for Solana: m/44'/501'/0'/0'
-    const child = hdkey.derive("m/44'/501'/0'/0'");
-    if (!child.privateKey) throw new Error('Solana key derivation failed');
-    return Keypair.fromSeed(child.privateKey.slice(0, 32));
-  }
-}

package/src/lib/chains/xrpl.ts

@@ -1,63 +0,0 @@
-import { Client, Wallet, xrpToDrops } from 'xrpl';
-import { WalletManager } from '../../server/payments/wallet.js';
-import type { RouteParams } from '../../server/payments/router.js';
-
-export class XRPLChain {
-  private static instance: XRPLChain;
-  private readonly rpcUrl: string;
-
-  private constructor() {
-    this.rpcUrl = process.env['XRPL_RPC_URL'] ?? 'wss://xrplcluster.com';
-  }
-
-  static getInstance(): XRPLChain {
-    if (!XRPLChain.instance) {
-      XRPLChain.instance = new XRPLChain();
-    }
-    return XRPLChain.instance;
-  }
-
-  async sendPayment(params: RouteParams): Promise<string> {
-    const client = new Client(this.rpcUrl);
-    await client.connect();
-
-    try {
-      const wallet = await this.getWallet();
-
-      // RLUSD on XRPL or XRP-denominated drop equivalent
-      const tx = await client.submitAndWait(
-        {
-          TransactionType: 'Payment',
-          Account: wallet.address,
-          Destination: params.to,
-          Amount:
-            params.currency === 'RLUSD'
-              ? {
-                  currency: 'USD',
-                  issuer: process.env['RLUSD_ISSUER'] ?? 'rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh',
-                  value: params.amount,
-                }
-              : xrpToDrops(params.amount),
-        },
-        { wallet },
-      );
-
-      if (tx.result.meta && typeof tx.result.meta === 'object' && 'TransactionResult' in tx.result.meta) {
-        const meta = tx.result.meta as { TransactionResult: string };
-        if (meta.TransactionResult !== 'tesSUCCESS') {
-          throw new Error(`XRPL transaction failed: ${meta.TransactionResult}`);
-        }
-      }
-
-      const txResult = tx.result as unknown as { hash?: string };
-      return txResult.hash ?? 'unknown';
-    } finally {
-      await client.disconnect();
-    }
-  }
-
-  private async getWallet(): Promise<Wallet> {
-    const mnemonic = await WalletManager.getInstance().getSeed();
-    return Wallet.fromMnemonic(mnemonic, { mnemonicEncoding: 'bip39' });
-  }
-}

package/src/lib/credit/bureau.ts

@@ -1,65 +0,0 @@
-interface ScoreCache {
-  score: number;
-  fetchedAt: number;
-}
-
-const SCORE_CACHE_TTL = 300_000; // 5 minutes
-
-export class CreditBureau {
-  private static instance: CreditBureau;
-  private readonly cache = new Map<string, ScoreCache>();
-  private readonly baseUrl: string;
-
-  private constructor() {
-    this.baseUrl = process.env['PROOF402_URL'] ?? 'https://four02proof.onrender.com';
-  }
-
-  static getInstance(): CreditBureau {
-    if (!CreditBureau.instance) {
-      CreditBureau.instance = new CreditBureau();
-    }
-    return CreditBureau.instance;
-  }
-
-  async getScore(wallet: string): Promise<number> {
-    const now = Date.now();
-    const cached = this.cache.get(wallet);
-
-    if (cached && now - cached.fetchedAt < SCORE_CACHE_TTL) {
-      return cached.score;
-    }
-
-    try {
-      const res = await fetch(`${this.baseUrl}/v1/score/${wallet}`, {
-        signal: AbortSignal.timeout(5000),
-      });
-
-      if (res.ok) {
-        const body = (await res.json()) as { score: number };
-        this.cache.set(wallet, { score: body.score, fetchedAt: now });
-        return body.score;
-      }
-    } catch {
-      // Fall through to default
-    }
-
-    // Default score for new/unknown agents
-    const defaultScore = 300;
-    this.cache.set(wallet, { score: defaultScore, fetchedAt: now });
-    return defaultScore;
-  }
-
-  async incrementScore(wallet: string, delta: number): Promise<void> {
-    try {
-      await fetch(`${this.baseUrl}/v1/score/${wallet}/increment`, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ delta }),
-      });
-      // Invalidate cache
-      this.cache.delete(wallet);
-    } catch {
-      // Non-fatal
-    }
-  }
-}

package/src/lib/sml-api/agentcard.ts

@@ -1,40 +0,0 @@
-const AGENTCARD_BASE = process.env['AGENTCARD_URL'] ?? 'https://agentcard.onrender.com';
-
-async function acGet(path: string): Promise<unknown> {
-  const res = await fetch(`${AGENTCARD_BASE}${path}`, {
-    headers: { 'Accept': 'application/json' },
-    signal: AbortSignal.timeout(10_000),
-  });
-  if (!res.ok) throw new Error(`AgentCard GET ${path}: HTTP ${res.status}`);
-  return res.json();
-}
-
-export interface AgentCardMintParams {
-  walletAddress: string;
-  name: string;
-  did?: string;
-  metadata?: Record<string, unknown>;
-}
-
-export interface AgentCardVerifyParams {
-  walletAddress: string;
-  message: string;
-  signature: string;
-}
-
-async function acPost(path: string, body: unknown): Promise<unknown> {
-  const res = await fetch(`${AGENTCARD_BASE}${path}`, {
-    method: 'POST',
-    headers: { 'Accept': 'application/json', 'Content-Type': 'application/json' },
-    body: JSON.stringify(body),
-    signal: AbortSignal.timeout(15_000),
-  });
-  if (!res.ok) throw new Error(`AgentCard POST ${path}: HTTP ${res.status}`);
-  return res.json();
-}
-
-export const AgentCardAPI = {
-  lookup: (walletOrDid: string) => acGet(`/v1/card/${encodeURIComponent(walletOrDid)}`),
-  verify: (params: AgentCardVerifyParams) => acPost('/v1/verify', params),
-  mint: (params: AgentCardMintParams) => acPost('/v1/mint', params),
-};

package/src/lib/sml-api/backtest.ts

@@ -1,47 +0,0 @@
-// backtester-mcp microservice client
-// Wraps the Python backtest_service.py running at BACKTEST_BASE_URL
-
-const BASE = process.env.BACKTEST_BASE_URL ?? 'http://localhost:8300';
-
-export interface BacktestParams {
-  ticker: string;
-  lookback_days?: number;
-  signals?: number[];
-  fees?: number;
-  slippage?: number;
-  momentum_window?: number;
-  momentum_threshold?: number;
-}
-
-export interface ValidateParams {
-  ticker: string;
-  lookback_days?: number;
-  train_ratio?: number;
-  fees?: number;
-  slippage?: number;
-}
-
-async function post(path: string, body: object): Promise<unknown> {
-  const res = await fetch(`${BASE}${path}`, {
-    method: 'POST',
-    headers: { 'Content-Type': 'application/json' },
-    body: JSON.stringify(body),
-    signal: AbortSignal.timeout(30_000),
-  });
-  if (!res.ok) {
-    const err = await res.json().catch(() => ({ error: res.statusText }));
-    throw new Error((err as { error?: string }).error ?? res.statusText);
-  }
-  return res.json();
-}
-
-export const BacktestAPI = {
-  health: async (): Promise<unknown> => {
-    const res = await fetch(`${BASE}/health`, { signal: AbortSignal.timeout(5_000) });
-    return res.json();
-  },
-
-  backtest: (params: BacktestParams): Promise<unknown> => post('/backtest', params),
-
-  walkForward: (params: ValidateParams): Promise<unknown> => post('/validate', params),
-};

package/src/lib/sml-api/brokers.ts

@@ -1,160 +0,0 @@
-// Broker execution rails — Robinhood + Tradier
-// Robinhood: OAuth2 Bearer token (ROBINHOOD_ACCESS_TOKEN env)
-// Tradier:   Bearer token (TRADIER_API_KEY env, TRADIER_ENV=sandbox|production)
-
-const TRADIER_BASE = process.env.TRADIER_ENV === 'production'
-  ? 'https://api.tradier.com/v1'
-  : 'https://sandbox.tradier.com/v1';
-
-const ROBINHOOD_BASE = 'https://api.robinhood.com';
-
-// ── Shared fetch helpers ────────────────────────────────────────────────────
-
-async function tradierGet(path: string, params?: Record<string, string>): Promise<unknown> {
-  const token = process.env.TRADIER_API_KEY;
-  if (!token) throw new Error('TRADIER_API_KEY not configured');
-  const url = new URL(`${TRADIER_BASE}${path}`);
-  if (params) Object.entries(params).forEach(([k, v]) => url.searchParams.set(k, v));
-  const res = await fetch(url.toString(), {
-    headers: { Authorization: `Bearer ${token}`, Accept: 'application/json' },
-    signal: AbortSignal.timeout(10_000),
-  });
-  if (!res.ok) throw new Error(`Tradier ${res.status}: ${res.statusText}`);
-  return res.json();
-}
-
-async function tradierPost(path: string, body: Record<string, string>): Promise<unknown> {
-  const token = process.env.TRADIER_API_KEY;
-  if (!token) throw new Error('TRADIER_API_KEY not configured');
-  const res = await fetch(`${TRADIER_BASE}${path}`, {
-    method: 'POST',
-    headers: {
-      Authorization: `Bearer ${token}`,
-      Accept: 'application/json',
-      'Content-Type': 'application/x-www-form-urlencoded',
-    },
-    body: new URLSearchParams(body).toString(),
-    signal: AbortSignal.timeout(10_000),
-  });
-  if (!res.ok) throw new Error(`Tradier ${res.status}: ${res.statusText}`);
-  return res.json();
-}
-
-async function robinhoodGet(path: string): Promise<unknown> {
-  const token = process.env.ROBINHOOD_ACCESS_TOKEN;
-  if (!token) throw new Error('ROBINHOOD_ACCESS_TOKEN not configured');
-  const res = await fetch(`${ROBINHOOD_BASE}${path}`, {
-    headers: { Authorization: `Bearer ${token}`, Accept: 'application/json' },
-    signal: AbortSignal.timeout(10_000),
-  });
-  if (!res.ok) throw new Error(`Robinhood ${res.status}: ${res.statusText}`);
-  return res.json();
-}
-
-async function robinhoodPost(path: string, body: object): Promise<unknown> {
-  const token = process.env.ROBINHOOD_ACCESS_TOKEN;
-  if (!token) throw new Error('ROBINHOOD_ACCESS_TOKEN not configured');
-  const res = await fetch(`${ROBINHOOD_BASE}${path}`, {
-    method: 'POST',
-    headers: {
-      Authorization: `Bearer ${token}`,
-      Accept: 'application/json',
-      'Content-Type': 'application/json',
-    },
-    body: JSON.stringify(body),
-    signal: AbortSignal.timeout(10_000),
-  });
-  if (!res.ok) throw new Error(`Robinhood ${res.status}: ${res.statusText}`);
-  return res.json();
-}
-
-// ── Tradier API ─────────────────────────────────────────────────────────────
-
-export interface TradierQuoteParams { symbols: string }
-export interface TradierOrderParams {
-  account_id: string;
-  symbol: string;
-  side: 'buy' | 'sell';
-  quantity: number;
-  type: 'market' | 'limit' | 'stop' | 'stop_limit';
-  duration: 'day' | 'gtc' | 'pre' | 'post';
-  price?: number;
-  stop?: number;
-}
-
-export const TradierAPI = {
-  quote: (params: TradierQuoteParams) =>
-    tradierGet('/markets/quotes', { symbols: params.symbols, greeks: 'false' }),
-
-  optionChain: (symbol: string, expiration: string) =>
-    tradierGet('/markets/options/chains', { symbol, expiration, greeks: 'true' }),
-
-  order: (params: TradierOrderParams) => {
-    const body: Record<string, string> = {
-      class: 'equity',
-      symbol: params.symbol,
-      side: params.side,
-      quantity: String(params.quantity),
-      type: params.type,
-      duration: params.duration,
-    };
-    if (params.price !== undefined) body.price = String(params.price);
-    if (params.stop !== undefined) body.stop = String(params.stop);
-    return tradierPost(`/accounts/${params.account_id}/orders`, body);
-  },
-
-  positions: (account_id: string) =>
-    tradierGet(`/accounts/${account_id}/positions`),
-
-  balances: (account_id: string) =>
-    tradierGet(`/accounts/${account_id}/balances`),
-
-  orderStatus: (account_id: string, order_id: string) =>
-    tradierGet(`/accounts/${account_id}/orders/${order_id}`),
-};
-
-// ── Robinhood API ────────────────────────────────────────────────────────────
-
-export interface RobinhoodOrderParams {
-  symbol: string;
-  side: 'buy' | 'sell';
-  quantity: number;
-  type: 'market' | 'limit';
-  time_in_force: 'gfd' | 'gtc' | 'ioc' | 'opg';
-  price?: number;
-}
-
-export const RobinhoodAPI = {
-  quote: async (symbol: string) => {
-    const data = await robinhoodGet(`/quotes/?symbols=${symbol}`) as { results?: unknown[] };
-    return data.results?.[0] ?? data;
-  },
-
-  instruments: async (symbol: string) => {
-    const data = await robinhoodGet(`/instruments/?symbol=${symbol}`) as { results?: { url: string }[] };
-    return data.results?.[0];
-  },
-
-  order: async (params: RobinhoodOrderParams) => {
-    const instrument = await RobinhoodAPI.instruments(params.symbol) as { url?: string } | undefined;
-    if (!instrument?.url) throw new Error(`Instrument not found: ${params.symbol}`);
-    const body: Record<string, unknown> = {
-      account: `/accounts/${process.env.ROBINHOOD_ACCOUNT_ID}/`,
-      instrument: instrument.url,
-      symbol: params.symbol,
-      side: params.side,
-      quantity: params.quantity,
-      type: params.type,
-      time_in_force: params.time_in_force,
-      trigger: 'immediate',
-    };
-    if (params.price !== undefined) body.price = String(params.price);
-    return robinhoodPost('/orders/', body);
-  },
-
-  portfolio: () => robinhoodGet('/portfolios/'),
-
-  positions: () => robinhoodGet('/positions/?nonzero=true'),
-
-  orderHistory: () => robinhoodGet('/orders/?page_size=20'),
-};

package/src/lib/sml-api/copytrader.ts

@@ -1,33 +0,0 @@
-const COPYTRADER_BASE = process.env['SML_COPYTRADER_URL'] ?? 'https://sml-copytrader.onrender.com';
-
-async function ctGet(path: string): Promise<unknown> {
-  const res = await fetch(`${COPYTRADER_BASE}${path}`, {
-    headers: { 'Accept': 'application/json' },
-    signal: AbortSignal.timeout(15_000),
-  });
-  if (!res.ok) throw new Error(`CopyTrader GET ${path}: HTTP ${res.status}`);
-  return res.json();
-}
-
-export interface CopyTraderSubscribeParams {
-  whaleAddress: string;
-  subscriberAddress: string;
-  maxCopyAmountXrp: number;
-}
-
-async function ctPost(path: string, body: unknown): Promise<unknown> {
-  const res = await fetch(`${COPYTRADER_BASE}${path}`, {
-    method: 'POST',
-    headers: { 'Accept': 'application/json', 'Content-Type': 'application/json' },
-    body: JSON.stringify(body),
-    signal: AbortSignal.timeout(15_000),
-  });
-  if (!res.ok) throw new Error(`CopyTrader POST ${path}: HTTP ${res.status}`);
-  return res.json();
-}
-
-export const CopyTraderAPI = {
-  status: () => ctGet('/status'),
-  whales: () => ctGet('/whales'),
-  subscribe: (params: CopyTraderSubscribeParams) => ctPost('/subscribe', params),
-};

package/src/lib/sml-api/crawl.ts

@@ -1,44 +0,0 @@
-export interface CrawlParams {
-  url: string;
-  extract: 'text' | 'links' | 'tables' | 'structured' | 'all';
-  userAgent?: string;
-}
-
-export interface CrawlResult {
-  url: string;
-  content: string | unknown;
-  status_code: number;
-  content_type: string;
-  fetched_at: string;
-}
-
-export class CrawlClient {
-  private static instance: CrawlClient;
-  private readonly baseUrl: string;
-
-  private constructor() {
-    this.baseUrl = process.env['SML_API_BASE'] ?? 'https://api.scriptmasterlabs.com';
-  }
-
-  static getInstance(): CrawlClient {
-    if (!CrawlClient.instance) {
-      CrawlClient.instance = new CrawlClient();
-    }
-    return CrawlClient.instance;
-  }
-
-  async fetch(params: CrawlParams): Promise<CrawlResult> {
-    const res = await fetch(`${this.baseUrl}/crawl/v1/fetch`, {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        ...(params.userAgent ? { 'X-Crawl-User-Agent': params.userAgent } : {}),
-      },
-      body: JSON.stringify({ url: params.url, extract: params.extract }),
-      signal: AbortSignal.timeout(30_000),
-    });
-
-    if (!res.ok) throw new Error(`Crawl API error: HTTP ${res.status}`);
-    return res.json() as Promise<CrawlResult>;
-  }
-}

package/src/lib/sml-api/echo.ts

@@ -1,28 +0,0 @@
-// echo-forge — historical pattern similarity engine (Polygon.io + ML cosine similarity)
-// Status: NOT YET DEPLOYED. Returns informative stub response until service is live.
-
-export interface EchoPatternParams {
-  symbol: string;
-  lookbackDays: number;
-  topN?: number;
-  walletAddress: string;
-}
-
-export const EchoForgeAPI = {
-  patternMatch: async (params: EchoPatternParams): Promise<unknown> => {
-    // Service not yet deployed to Render — surface clear coming-soon message.
-    return {
-      status: 'coming_soon',
-      service: 'echo-forge',
-      message:
-        'echo-forge (historical pattern similarity engine) is not yet deployed. ' +
-        'It uses Polygon.io data + ML cosine similarity to find historical analogs. ' +
-        'Check https://github.com/Timwal78/echo-forge for status updates.',
-      params_received: {
-        symbol: params.symbol,
-        lookback_days: params.lookbackDays,
-        top_n: params.topN ?? 5,
-      },
-    };
-  },
-};

package/src/lib/sml-api/forge.ts

@@ -1,33 +0,0 @@
-const FORGE_BASE = process.env['FORGE_GATEWAY_URL'] ?? 'https://forge-gateway-a822.onrender.com';
-
-async function forgeGet(path: string): Promise<unknown> {
-  const res = await fetch(`${FORGE_BASE}${path}`, {
-    headers: { 'Accept': 'application/json' },
-    signal: AbortSignal.timeout(15_000),
-  });
-  if (!res.ok) throw new Error(`Forge Gateway GET ${path}: HTTP ${res.status}`);
-  return res.json();
-}
-
-export interface ForgeLLMParams {
-  model: string;
-  prompt: string;
-  maxTokens?: number;
-  walletAddress: string;
-}
-
-async function forgePost(path: string, body: unknown): Promise<unknown> {
-  const res = await fetch(`${FORGE_BASE}${path}`, {
-    method: 'POST',
-    headers: { 'Accept': 'application/json', 'Content-Type': 'application/json' },
-    body: JSON.stringify(body),
-    signal: AbortSignal.timeout(60_000),
-  });
-  if (!res.ok) throw new Error(`Forge Gateway POST ${path}: HTTP ${res.status}`);
-  return res.json();
-}
-
-export const ForgeGatewayAPI = {
-  status: () => forgeGet('/health'),
-  llm: (params: ForgeLLMParams) => forgePost('/v1/llm', params),
-};