SDKs, MCP and frameworks.

One request

npm install @usdf/sdk viem

import { USDF } from "@usdf/sdk";
import { privateKeyToAccount } from "viem/accounts";
const wallet = privateKeyToAccount(process.env.PAYER_KEY as `0x${string}`);
const usdf = new USDF({ wallet }); // or new USDF({ apiKey: process.env.USDF_API_KEY })
const result = await usdf.run("<model>", "Hello");

Generate text

npm install @usdf/sdk ai

import { generateText } from "ai";
import { usdf } from "@usdf/sdk/ai"; // charges USDF_API_KEY; createUSDF({ wallet }) from "@usdf/sdk/ai" pays per request from a wallet
const model = usdf("<model>");
const result = await generateText({ model, prompt: "Hello" });

The openai package

npm install openai

import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.usdf.fi/v1",
  apiKey: process.env.USDF_API_KEY,
});

const completion = await client.chat.completions.create({
  model: "<model>",
  messages: [{ role: "user", content: "Hello" }],
  max_tokens: 256,
});
console.log(completion.choices[0].message.content);

// The receipt is an extra field the SDK's types do not declare.
const { receipt } = completion as unknown as {
  receipt: { request_id: string; cost: { usdf: string } };
};
console.log(receipt.request_id, receipt.cost.usdf, "USDF");

createOpenAICompatible

npm install @ai-sdk/openai-compatible@3.0.54 ai@7.0.112

import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
import { generateText } from "ai";

const usdf = createOpenAICompatible({
  name: "usdf",
  baseURL: "https://api.usdf.fi/v1",
  apiKey: process.env.USDF_API_KEY,
});

const { text, response } = await generateText({
  model: usdf("<model>"),
  prompt: "Hello",
  maxOutputTokens: 256,
});
console.log(text, response.id);

ChatOpenAI

npm install @langchain/openai

import { ChatOpenAI } from "@langchain/openai";

const llm = new ChatOpenAI({
  model: "<model>",
  apiKey: process.env.USDF_API_KEY,
  maxTokens: 256,
  configuration: { baseURL: "https://api.usdf.fi/v1" },
});
const reply = await llm.invoke("Hello");
console.log(reply.content);

{
  "mcpServers": {
    "usdf": {
      "url": "https://api.usdf.fi/mcp",
      "headers": { "Authorization": "Bearer ${env:USDF_API_KEY}" }
    }
  }
}

{
  "mcpServers": {
    "usdf": {
      "command": "npx",
      "args": ["-y", "mcp-remote@0.14.3", "https://api.usdf.fi/mcp", "--header", "Authorization:${USDF_AUTH}"],
      "env": { "USDF_AUTH": "Bearer sk_..." }
    }
  }
}

The MCP TypeScript SDK

npm install @modelcontextprotocol/sdk@1.30.0

import { Client } from "@modelcontextprotocol/sdk/client/index.js";
import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";

const transport = new StreamableHTTPClientTransport(new URL("https://api.usdf.fi/mcp"), {
  requestInit: { headers: { Authorization: `Bearer ${process.env.USDF_API_KEY}` } },
});
const client = new Client({ name: "my-agent", version: "1.0.0" });
await client.connect(transport);

const { tools } = await client.listTools();
console.log(tools.map((t) => t.name));

const quote = await client.callTool({
  name: "quote",
  arguments: { model: "<model>", prompt: "Hello", max_tokens: 256 },
});
console.log(JSON.stringify(quote.structuredContent));

// With onprogress the SDK sends a progress token: the gateway reports progress
// as it works and allows the call up to 10 minutes. resetTimeoutOnProgress is
// what makes the client keep waiting.
const chat = await client.callTool(
  { name: "chat", arguments: { model: "<model>", messages: [{ role: "user", content: "Hello" }], max_tokens: 256 } },
  undefined,
  { timeout: 60_000, resetTimeoutOnProgress: true, onprogress: (p) => console.log("still generating", p.progress) },
);
console.log(JSON.stringify(chat.structuredContent));
await client.close();