Next.js

export const POST = forge.withForge(withX402(handler, { "/api/text-stats": routeConfig }, resourceServer));

export const proxy = forge.proxy(paymentProxy(routes, resourceServer));

// Shared setup: one Forge instance and one x402 resource server for all route handlers.
// Forge lines are marked (forge).
import { HTTPFacilitatorClient } from "@x402/core/server";
import { ExactEvmScheme } from "@x402/evm/exact/server";
import { x402ResourceServer } from "@x402/next";
import { createForge } from "@forgeintel/sdk/next"; // (forge)

export const NETWORK = (process.env.NETWORK ?? "eip155:84532") as `${string}:${string}`; // Base Sepolia; eip155:8453 for mainnet
export const PAY_TO = process.env.PAY_TO ?? "";
if (!PAY_TO) console.warn("Set PAY_TO to the address that receives payments");

export const resourceServer = new x402ResourceServer(
  new HTTPFacilitatorClient({ url: process.env.FACILITATOR_URL ?? "https://x402.org/facilitator" }),
).register(NETWORK, new ExactEvmScheme());

// (forge) With missing env (e.g. during `next build`) Forge warns and turns itself off instead of throwing.
export const forge = createForge({
  apiKey: process.env.FORGE_API_KEY ?? "",
  backendUrl: process.env.FORGE_BACKEND_URL ?? "",
  publicUrl: process.env.PUBLIC_URL ?? "",
});

// A paid route: withX402 handles payment, and forge.withForge wraps it (outermost) to add the rating ask to
// the 402, the feedback fields to the paid response, and to read agent context.
import { withX402 } from "@x402/next";
import { NextResponse, type NextRequest } from "next/server";
import { NETWORK, PAY_TO, forge, resourceServer } from "@/lib/forge";

async function handler(request: NextRequest): Promise<NextResponse> {
  const body = await request.json().catch(() => ({}));
  const text = typeof body?.text === "string" ? body.text : "";
  if (!text) return NextResponse.json({ error: "text is required" }, { status: 400 });
  const words = text.split(/\s+/).filter(Boolean).length;
  return NextResponse.json({
    characters: text.length,
    words,
    sentences: text.split(/[.!?]+/).filter((s: string) => s.trim()).length,
    reading_time_seconds: Math.ceil((words / 238) * 60),
  });
}

export const POST = forge.withForge( // (forge)
  withX402(
    handler,
    {
      "/api/text-stats": {
        accepts: { scheme: "exact", price: "$0.001", network: NETWORK, payTo: PAY_TO },
        description: "Count characters, words and sentences in a text and estimate reading time.",
        mimeType: "application/json",
      },
    },
    resourceServer,
  ),
);

// (forge) Forge's own routes: /feedback, /feedback/rate and /feedback/summary.
import { forge } from "@/lib/forge";

export const { GET, POST, HEAD } = forge.routes;

// Your OpenAPI document. Wrapped with forge.withForge, it's served enriched: the rating routes, feedback fields
// and optional agent context are documented, so discovery tools (e.g. agentcash) show them before the call.
import { NextResponse } from "next/server";
import { forge } from "@/lib/forge";

const spec = {
  openapi: "3.1.0",
  info: {
    title: "Text stats",
    version: "1.0.0",
    "x-guidance": "POST /api/text-stats with {\"text\": \"...\"} returns character, word and sentence counts ($0.001, x402).",
  },
  servers: [{ url: process.env.PUBLIC_URL ?? "http://localhost:4026" }],
  paths: {
    "/api/text-stats": {
      post: {
        requestBody: {
          required: true,
          content: { "application/json": { schema: { type: "object", required: ["text"], properties: { text: { type: "string" } } } } },
        },
        responses: {
          "200": {
            description: "Counts.",
            content: {
              "application/json": {
                schema: {
                  type: "object",
                  properties: {
                    characters: { type: "integer" },
                    words: { type: "integer" },
                    sentences: { type: "integer" },
                    reading_time_seconds: { type: "integer" },
                  },
                },
              },
            },
          },
          "402": { description: "Payment required." },
        },
      },
    },
  },
};

export const GET = forge.withForge(async () => NextResponse.json(spec)); // (forge)