Integration Guide

bun add @ottocode/ai-sdk ai
# or
npm install @ottocode/ai-sdk ai

import { createSetu } from "@ottocode/ai-sdk";
import { generateText } from "ai";

const setu = createSetu({
  auth: { privateKey: process.env.SETU_PRIVATE_KEY! },
});

const { text } = await generateText({
  model: setu.model("claude-sonnet-4-6"),
  prompt: "Hello!",
});

console.log(text);

setu.model("claude-sonnet-4-6");      // → anthropic
setu.model("gpt-5");                  // → openai
setu.model("gemini-3-flash-preview"); // → google
setu.model("kimi-k2.5");              // → moonshot

const model = setu.provider("openai").model("gpt-5");
const model = setu.provider("anthropic", "anthropic-messages").model("claude-sonnet-4-6");

import { streamText } from "ai";

const result = streamText({
  model: setu.model("claude-sonnet-4-6"),
  prompt: "Write a short story about a robot.",
});

for await (const chunk of result.textStream) {
  process.stdout.write(chunk);
}

import { generateText, tool } from "ai";
import { z } from "zod";

const { text } = await generateText({
  model: setu.model("claude-sonnet-4-6"),
  prompt: "What's the weather in Tokyo?",
  tools: {
    getWeather: tool({
      description: "Get weather for a location",
      parameters: z.object({
        location: z.string(),
      }),
      execute: async ({ location }) => {
        return { temperature: 22, condition: "cloudy" };
      },
    }),
  },
});

// Default: auto caching (1 system + 1 message breakpoint)
createSetu({ auth });

// Disable completely
createSetu({ auth, cache: { anthropicCaching: false } });

// Manual: SDK won't inject cache_control — set it yourself
createSetu({ auth, cache: { anthropicCaching: { strategy: "manual" } } });

// Custom breakpoint count
createSetu({
  auth,
  cache: {
    anthropicCaching: {
      systemBreakpoints: 2,
      messageBreakpoints: 3,
      messagePlacement: "last",
    },
  },
});

const { text } = await generateText({
  model: setu.model("claude-sonnet-4-6"),
  prompt: "Solve this complex math problem...",
  providerOptions: {
    anthropic: {
      thinking: { type: "enabled", budgetTokens: 16000 },
    },
  },
});

const setu = createSetu({
  // Required: Solana wallet private key (base58)
  auth: { privateKey: "..." },

  // Optional: Setu API base URL (default: https://api.setu.ottocode.io)
  baseURL: "https://api.setu.ottocode.io",

  // Optional: Solana RPC URL (default: https://api.mainnet-beta.solana.com)
  rpcURL: "https://api.mainnet-beta.solana.com",

  // Optional: Payment callbacks (see below)
  callbacks: { /* ... */ },

  // Optional: Cache configuration
  cache: { /* ... */ },

  // Optional: Payment options
  payment: {
    topupApprovalMode: "auto",    // "auto" | "approval"
    autoPayThresholdUsd: 5.0,
    maxRequestAttempts: 3,
    maxPaymentAttempts: 20,
  },

  // Optional: Custom model→provider mappings
  modelMap: { "my-custom-model": "openai" },

  // Optional: Register custom providers
  providers: [
    { id: "my-provider", apiFormat: "openai-chat", modelPrefix: "myp-" },
  ],
});

import { createSetu } from "@ottocode/ai-sdk";
import { generateText } from "ai";

const setu = createSetu({
	auth: {
		signer: {
			walletAddress: "YOUR_SOLANA_PUBLIC_KEY",

			// Required: sign auth nonces
			signNonce: async (nonce) => {
				return await myWallet.signMessage(nonce);
			},

			// Optional: sign payment transactions (raw bytes in, signed bytes out)
			signTransaction: async (transaction) => {
				return await myWallet.signTransaction(transaction);
			},
		},
	},
});

const { text } = await generateText({
	model: setu.model("claude-sonnet-4-6"),
	prompt: "Hello!",
});

const setu = createSetu({
	auth: {
		signer: {
			walletAddress: wallet.publicKey.toBase58(),
			signNonce: async (nonce) => {
				const encoded = new TextEncoder().encode(nonce);
				const { signature } = await wallet.signMessage(encoded);
				return bs58.encode(signature);
			},
			signTransaction: async (txBytes) => {
				const tx = Transaction.from(txBytes);
				const signed = await wallet.signTransaction(tx);
				return signed.serialize();
			},
		},
	},
});

const setu = createSetu({
	auth: {
		signer: {
			walletAddress: "YOUR_SOLANA_PUBLIC_KEY",
			signNonce: async (nonce) => {
				return await myWallet.signMessage(nonce);
			},
		},
	},
});

const setu = createSetu({
  auth: { privateKey: "..." },
  callbacks: {
    onPaymentRequired: (amountUsd, currentBalance) => {
      console.log(`Payment required: $${amountUsd}`);
    },
    onPaymentSigning: () => {
      console.log("Signing payment...");
    },
    onPaymentComplete: ({ amountUsd, newBalance, transactionId }) => {
      console.log(`Paid $${amountUsd}, balance: $${newBalance}`);
    },
    onPaymentError: (error) => {
      console.error("Payment failed:", error);
    },
    onBalanceUpdate: ({ costUsd, balanceRemaining, inputTokens, outputTokens }) => {
      console.log(`Cost: $${costUsd}, remaining: $${balanceRemaining}`);
    },
    onPaymentApproval: async ({ amountUsd, currentBalance }) => {
      // return "crypto" to pay, "fiat" for fiat flow, "cancel" to abort
      return "crypto";
    },
  },
});

// Setu account balance
const balance = await setu.balance();
// { walletAddress, balance, totalSpent, totalTopups, requestCount }

// On-chain USDC balance
const wallet = await setu.walletBalance("mainnet");
// { walletAddress, usdcBalance, network }

// Wallet address
console.log(setu.walletAddress);

const customFetch = setu.fetch();

const response = await customFetch(
  "https://api.setu.ottocode.io/v1/messages",
  {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({
      model: "claude-sonnet-4-6",
      messages: [{ role: "user", content: "Hello" }],
      max_tokens: 1024,
    }),
  }
);

import {
  fetchBalance,
  fetchWalletUsdcBalance,
  getPublicKeyFromPrivate,
  addAnthropicCacheControl,
  createSetuFetch,
} from "@ottocode/ai-sdk";

// Get wallet address from private key
const address = getPublicKeyFromPrivate(privateKey);

// Fetch balance without creating a full Setu instance
const balance = await fetchBalance({ privateKey });

// Fetch on-chain USDC
const usdc = await fetchWalletUsdcBalance({ privateKey }, "mainnet");

import nacl from "tweetnacl";
import bs58 from "bs58";
import { Keypair } from "@solana/web3.js";

const keypair = Keypair.fromSecretKey(
  bs58.decode(process.env.SETU_PRIVATE_KEY)
);

const nonce = Date.now().toString();
const signature = nacl.sign.detached(
  new TextEncoder().encode(nonce),
  keypair.secretKey
);

const response = await fetch(
  "https://api.setu.ottocode.io/v1/messages",
  {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "x-wallet-address": keypair.publicKey.toBase58(),
      "x-wallet-signature": bs58.encode(signature),
      "x-wallet-nonce": nonce,
    },
    body: JSON.stringify({
      model: "claude-sonnet-4-6",
      max_tokens: 1024,
      messages: [
        { role: "user", content: "Hello, Claude!" }
      ],
    }),
  }
);

if (response.status === 402) {
  // Handle payment — see Payments docs
}

const data = await response.json();
console.log(data.content[0].text);

# Login with Setu (generates or imports a Solana wallet)
otto auth login setu

# Or set the private key directly
export SETU_PRIVATE_KEY="your-base58-private-key"

# Use Setu as default provider
otto setup  # select "setu"

# Or per-request
otto ask "hello" --provider setu --model claude-sonnet-4-6