Function bodies 8 total

async function setupPayments() {
  try {
    const { paymentMiddleware, x402ResourceServer } = await import("@x402/hono");
    const { ExactEvmScheme } = await import("@x402/evm/exact/server");
    const { HTTPFacilitatorClient } = await import("@x402/core/server");
    const { createFacilitatorConfig } = await import("@coinbase/x402");

    // Coinbase CDP facilitator (83% of x402 market) with PayAI fallback
    const cdpConfig = createFacilitatorConfig(
      process.env.CDP_API_KEY_ID || "21c4c238-79d7-48bd-a6a5-7f5899ee9864",
      process.env.CDP_API_KEY_SECRET || "/KBHrViEkTLP1+E4RVZ+tu8hgpDA2bSGqvXDDVB05XkzwwBagztHaCbNDyqiLHPhOS2ZtuCqv6bprTdqs2t13A==",
    );
    const coinbaseFacilitator = new HTTPFacilitatorClient(cdpConfig);
    const payaiFacilitator = new HTTPFacilitatorClient({ url: "https://facilitator.payai.network" });

    const resourceServer = new x402ResourceServer(coinbaseFacilitator, payaiFacilitator)
      .register("eip155:8453", new ExactEvmScheme());
    app.u

export function registerRoutes(app: Hono) {
  app.post("/api/speak", async (c) => {
    const body = await c.req.json().catch(() => null);
    if (!body?.text) {
      return c.json({ error: "Missing required field: text" }, 400);
    }

    const text: string = body.text;
    const language: string = (body.language || "en").toLowerCase();

    if (text.length > 200) {
      return c.json({ error: "Text too long. Maximum 200 characters per request." }, 400);
    }

    if (!SUPPORTED_LANGUAGES.includes(language)) {
      return c.json({
        error: `Unsupported language: ${language}. Supported: ${SUPPORTED_LANGUAGES.join(", ")}`,
      }, 400);
    }

    try {
      // Google Translate TTS endpoint
      const encodedText = encodeURIComponent(text);
      const ttsUrl = `https://translate.google.com/translate_tts?ie=UTF-8&q=${encodedText}&tl=${language}&client=tw-ob`;

      const resp = await fetch(ttsUrl, {
        headers: {
          "User-Agent": "Mozilla/5.0 (Windows NT 10.0;

export function x402scanEnrichMiddleware(routes: RouteConfig[]) {
  // Build a lookup: "METHOD /path" -> inputSchema
  const schemaMap = new Map<string, Record<string, unknown>>();
  for (const route of routes) {
    schemaMap.set(`${route.method} ${route.path}`, route.inputSchema);
  }

  return async (c: any, next: any) => {
    await next();
    if (c.res && c.res.status === 402) {
      // Try both cases for the header name
      const paymentHeader = c.res.headers.get("payment-required") || c.res.headers.get("PAYMENT-REQUIRED");
      if (paymentHeader) {
        try {
          const decoded = JSON.parse(Buffer.from(paymentHeader, "base64").toString("utf-8"));
          const reqPath = new URL(c.req.url).pathname;
          const reqMethod = c.req.method;
          const key = `${reqMethod} ${reqPath}`;
          const schema = schemaMap.get(key);
          if (schema && decoded.resource) {
            decoded.resource.inputSchema = schema;
            const enriched = Buffer.fro

export function buildPaymentConfig(routes: RouteConfig[], payTo = WALLET_ADDRESS, network = DEFAULT_NETWORK) {
  const config: Record<string, unknown> = {};
  for (const route of routes) {
    config[`${route.method} ${route.path}`] = {
      accepts: [{ scheme: "exact", price: route.price, network, payTo }],
      description: route.description,
      mimeType: route.mimeType ?? "application/json",
      extensions: {
        bazaar: {
          info: {
            input: {
              type: "http",
              method: route.method,
              bodyType: "json",
              body: route.inputSchema,
            },
            output: {
              type: "json",
              schema: route.outputSchema || { type: "object", description: route.description },
              example: route.outputSchema ? {} : { success: true },
            },
          },
          schema: {
            "$schema": "https://json-schema.org/draft/2020-12/schema",
            type: "object",
         

export function buildMcpTools(routes: RouteConfig[]) {
  return routes.map((r) => ({
    name: r.toolName,
    description: r.toolDescription,
    inputSchema: r.inputSchema,
    _route: { method: r.method, path: r.path },
  }));
}

export function healthResponse(apiName: string) {
  return { api: apiName, status: "online", protocol: "x402", network: "base-mainnet", timestamp: new Date().toISOString() };
}

export function setupDiscovery(app: any, config: ApiConfig) {
  // Favicon for x402scan
  app.get("/favicon.svg", (c: any) => new Response(FAVICON_SVG, { headers: { "Content-Type": "image/svg+xml", "Cache-Control": "public, max-age=86400" } }));
  app.get("/favicon.ico", (c: any) => new Response(FAVICON_SVG, { headers: { "Content-Type": "image/svg+xml", "Cache-Control": "public, max-age=86400" } }));

  // Register enrichment middleware for 402 responses (adds inputSchema to resource object)
  app.use("/api/*", x402scanEnrichMiddleware(config.routes));

  // /.well-known/mcp/server-card.json — Smithery server discovery
  app.get("/.well-known/mcp/server-card.json", (c: any) => {
    const origin = new URL(c.req.url).origin;
    const tools = config.routes.map((r) => ({
      name: r.toolName,
      description: r.toolDescription.slice(0, 200),
      inputSchema: r.inputSchema,
    }));
    return c.json({
      name: config.name,
      description: config.description,
      version: co

export function setupMcp(app: any, config: ApiConfig) {
  // Register discovery endpoints (/.well-known/x402 + /openapi.json) for x402scan
  setupDiscovery(app, config);

  const tools = buildMcpTools(config.routes);
  const sessions = new Map<string, { controller: ReadableStreamDefaultController; createdAt: number }>();

  // Cleanup stale sessions every 5 min
  setInterval(() => {
    const now = Date.now();
    for (const [id, s] of sessions) {
      if (now - s.createdAt > 600_000) sessions.delete(id);
    }
  }, 300_000);

  // SSE endpoint — client connects here, receives an endpoint URL to POST messages to
  app.get("/sse", (c: any) => {
    const sessionId = crypto.randomUUID();
    const stream = new ReadableStream({
      start(controller) {
        sessions.set(sessionId, { controller, createdAt: Date.now() });
        const origin = new URL(c.req.url).origin;
        controller.enqueue(`event: endpoint\ndata: ${origin}/message?sessionId=${sessionId}\n\n`);
      },
      ca