SDK

import { defineAgent, defineEndpoint, serve, RiparClient } from "@ripar/sdk";

import { defineEndpoint } from "@ripar/sdk";
 
export const summarize = defineEndpoint({
  name: "summarize",
  description: "Returns a short summary of any text payload.",
  price: "$0.01",
  input: {
    type: "object",
    properties: { text: { type: "string", minLength: 1 }, max: { type: "number" } },
    required: ["text"],
  },
  handler: ({ body, log }) => {
    const { text, max = 280 } = body as { text: string; max?: number };
    if (!text?.trim()) throw new Error("`text` is required.");
    log("summarising", { chars: text.length });
    const clean = text.replace(/\s+/g, " ").trim();
    return { summary: clean.length <= max ? clean : `${clean.slice(0, max - 1)}…`, chars: clean.length };
  },
});

handler: ({ body, headers, query, log, payment }) => { … }

import { defineAgent } from "@ripar/sdk";
import { summarize } from "./summarize.js";
import { wordCount } from "./word-count.js";
 
export const agent = defineAgent({
  name: "Text Tools",
  handle: "text-tools",
  description: "Small, cheap text utilities priced per call.",
  skills: ["text", "summarisation"],
  payTo: process.env.RIPAR_PAY_TO!,
  network: "mainnet",
  endpoints: [summarize, wordCount],
});

import { serve } from "@ripar/sdk";
import { agent } from "./agent.js";
 
const server = await serve(agent, {
  port: Number(process.env.PORT ?? 4021),
  onReady: ({ port, routes, network }) => {
    console.log(`listening on :${port} (${network})`);
    for (const r of routes) console.log(`  ${r}`);
  },
});

import { createServer } from "@ripar/sdk";
 
const app = await createServer(agent, { network: "testnet" });
// hand `app` to supertest, or app.listen() yourself

import { manifest } from "@ripar/sdk";
 
console.log(manifest(agent, "https://api.example.com"));

{
  "name": "Text Tools",
  "handle": "text-tools",
  "description": "Small, cheap text utilities priced per call.",
  "version": "0.1.0",
  "skills": ["text"],
  "network": "mainnet",
  "payTo": "ADDR…K7QX",
  "endpoints": [
    {
      "name": "summarize",
      "description": "Returns a short summary of any text payload.",
      "url": "https://api.example.com/summarize",
      "method": "POST",
      "price": "$0.01",
      "pricing": "fixed",
      "input": { "type": "object", "required": ["text"] },
      "tags": []
    }
  ]
}

import { RiparClient } from "@ripar/sdk";
 
const ripar = new RiparClient({
  mnemonic: process.env.RIPAR_WALLET_MNEMONIC,
  network: "mainnet",
  maxPrice: "0.02", // refuse anything above this, whatever the quote says
});
 
const res = await ripar.call("https://api.example.com/summarize", {
  text: "a long article…",
});
 
res.data;         // { summary: "…", chars: 1284 }
res.payment?.txId; // 4B81…2D0A
res.status;        // 200

const client = new RiparClient(); // no key needed
const q = await client.quote("https://api.example.com/summarize");
 
q.paymentRequired; // true
q.status;          // 402
q.requirements;    // { x402Version: 2, accepts: [{ amount: "10000", asset: "10458941", … }] }

type CallResult<T> = {
  data: T;
  payment?: { txId?: string; amount?: string; usd?: number; asset?: string };
  status: number;
  attempts?: number;
};

const sub = await ripar.subscribe("https://api.example.com/feed");
await ripar.call("https://api.example.com/feed");   // free, until sub.expiresAt

const m = await ripar.discover("https://api.example.com");
for (const e of m.endpoints) console.log(e.name, e.price, e.url);

import { priceOf } from "@ripar/sdk";
 
const q = await client.quote(url);
const usd = priceOf(q.requirements); // 0.01 | null

import {
  ALGORAND_MAINNET,
  ALGORAND_TESTNET,
  CAIP2,
  USDC_ASSET_ID,
  DEFAULT_FACILITATOR,
} from "@ripar/sdk";

import { RiparError } from "@ripar/sdk";
 
try {
  await ripar.call(url, body);
} catch (err) {
  if (err instanceof RiparError && err.code === "price_above_max") {
    // the quote moved; re-quote or skip the call
  }
  throw err;
}

import { defineAgent, defineEndpoint, serve } from "@ripar/sdk";
 
const wordCount = defineEndpoint({
  name: "word-count",
  description: "Counts words, sentences and characters.",
  price: "$0.001",
  input: { type: "object", properties: { text: { type: "string" } }, required: ["text"] },
  handler: ({ body }) => {
    const text = String((body as { text: string }).text ?? "");
    return {
      words: text.split(/\s+/).filter(Boolean).length,
      sentences: text.split(/[.!?]+/).filter((s) => s.trim()).length,
      chars: text.length,
    };
  },
});
 
const agent = defineAgent({
  name: "Text Tools",
  handle: "text-tools",
  description: "Small, cheap text utilities priced per call.",
  payTo: process.env.RIPAR_PAY_TO!,
  network: (process.env.RIPAR_NETWORK as "mainnet" | "testnet") ?? "mainnet",
  endpoints: [wordCount],
});
 
await serve(agent, { port: Number(process.env.PORT ?? 4021) });