@ottocode/openclaw-setu 0.1.0

package/README.md

@@ -0,0 +1,79 @@
+# @ottocode/openclaw-setu
+
+Setu provider plugin for [OpenClaw](https://github.com/openclaw/openclaw) — pay for AI with Solana USDC.
+
+No API keys. No accounts. Just a Solana wallet with USDC.
+
+## How It Works
+
+```
+OpenClaw → localhost:8403 (Setu proxy) → api.setu.ottocode.io → LLM provider
+```
+
+1. Auto-generates a Solana wallet (or import your own)
+2. Fund the wallet with USDC on Solana
+3. Each LLM request is signed with your wallet — payment IS authentication
+4. Access 30+ models across Anthropic, OpenAI, Google, DeepSeek, and more
+
+## Quick Start
+
+```bash
+# Install
+bun add @ottocode/openclaw-setu
+
+# Interactive setup (generates wallet, injects config)
+bunx openclaw-setu setup
+
+# Fund your wallet with USDC on Solana (address shown during setup)
+
+# Start the proxy
+bunx openclaw-setu start
+
+# Restart OpenClaw
+openclaw gateway restart
+```
+
+## CLI Commands
+
+```
+openclaw-setu setup              Interactive setup (wallet + config)
+openclaw-setu start              Start the local proxy server
+
+openclaw-setu wallet generate    Generate a new Solana wallet
+openclaw-setu wallet import      Import an existing private key
+openclaw-setu wallet export      Export your private key
+openclaw-setu wallet info        Show wallet address and balances
+
+openclaw-setu config inject      Inject Setu provider into openclaw.json
+openclaw-setu config remove      Remove Setu provider from openclaw.json
+openclaw-setu config status      Check if Setu is configured
+```
+
+## As an OpenClaw Plugin
+
+If OpenClaw loads the plugin automatically (via `openclaw.extensions` in package.json), Setu registers:
+
+- **Provider**: `setu` — appears in OpenClaw's auth wizard
+- **Service**: `setu-proxy` — auto-starts the local proxy with the gateway
+- **Commands**: `/wallet` (show balances), `/setu-status` (check config)
+
+## Wallet Storage
+
+- Private key: `~/.openclaw/setu/wallet.key` (mode 0600)
+- OpenClaw config: `~/.openclaw/openclaw.json`
+
+## Environment Variables
+
+- `SETU_PROXY_PORT` — Proxy port (default: 8403)
+- `SETU_PRIVATE_KEY` — Alternative to wallet file
+
+## How is this different from ClawRouter?
+
+| | Setu | ClawRouter |
+|---|---|---|
+| Chain | Solana | Base (EVM) |
+| Token | USDC (SPL) | USDC (ERC-20) |
+| Protocol | Solana wallet signatures | x402 / EIP-712 |
+| Proxy port | 8403 | 8402 |
+
+Both achieve the same goal: pay-per-token AI with no API keys. Choose based on which chain you prefer.

package/openclaw.plugin.json

@@ -0,0 +1,25 @@
+{
+  "id": "setu",
+  "name": "Setu",
+  "description": "Pay for AI with Solana USDC — 30+ models, no API keys, just a wallet.",
+  "configSchema": {
+    "type": "object",
+    "properties": {
+      "walletKey": {
+        "type": "string",
+        "description": "Solana wallet private key (base58). Optional — auto-generated if not set."
+      },
+      "baseURL": {
+        "type": "string",
+        "description": "Setu API base URL (default: https://api.setu.ottocode.io)"
+      }
+    }
+  },
+  "uiHints": {
+    "walletKey": {
+      "label": "Solana Wallet Private Key",
+      "sensitive": true,
+      "placeholder": "base58... (optional — auto-generated)"
+    }
+  }
+}

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@ottocode/openclaw-setu",
+  "version": "0.1.0",
+  "description": "Setu provider for OpenClaw — pay for AI with Solana USDC. No API keys, just a wallet.",
+  "type": "module",
+  "main": "./src/index.ts",
+  "exports": {
+    ".": "./src/index.ts"
+  },
+  "bin": {
+    "openclaw-setu": "./src/cli.ts"
+  },
+  "openclaw": {
+    "extensions": [
+      "./src/index.ts"
+    ]
+  },
+  "files": [
+    "src",
+    "openclaw.plugin.json"
+  ],
+  "keywords": [
+    "openclaw",
+    "setu",
+    "solana",
+    "usdc",
+    "ai",
+    "llm",
+    "pay-per-use",
+    "crypto"
+  ],
+  "author": "nitishxyz",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/nitishxyz/otto.git",
+    "directory": "packages/openclaw-setu"
+  },
+  "dependencies": {
+    "@ottocode/ai-sdk": "workspace:*"
+  },
+  "peerDependencies": {
+    "openclaw": ">=2025.1.0"
+  },
+  "peerDependenciesMeta": {
+    "openclaw": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "typescript": "^5.0.0"
+  }
+}

package/src/cli.ts

@@ -0,0 +1,272 @@
+#!/usr/bin/env bun
+
+import {
+  loadWallet,
+  saveWallet,
+  ensureWallet,
+  exportWalletKey,
+  getWalletKeyPath,
+  getSetuBalance,
+} from "./wallet.ts";
+import { injectConfig, removeConfig, isConfigured, getConfigPath } from "./config.ts";
+import { createProxy } from "./proxy.ts";
+import { isValidPrivateKey } from "@ottocode/ai-sdk";
+import * as readline from "node:readline";
+
+function prompt(question: string): Promise<string> {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+
+function printHelp() {
+  console.log(`
+openclaw-setu — Pay for AI with Solana USDC
+
+Usage:
+  openclaw-setu setup              Interactive setup (wallet + config)
+  openclaw-setu start              Start the local proxy server
+  openclaw-setu stop               Stop (placeholder — use Ctrl+C)
+
+  openclaw-setu wallet generate    Generate a new Solana wallet
+  openclaw-setu wallet import      Import an existing private key
+  openclaw-setu wallet export      Export your private key
+  openclaw-setu wallet info        Show wallet address and balances
+
+  openclaw-setu config inject      Inject Setu provider into openclaw.json
+  openclaw-setu config remove      Remove Setu provider from openclaw.json
+  openclaw-setu config status      Check if Setu is configured
+
+  openclaw-setu help               Show this help
+`);
+}
+
+async function cmdSetup() {
+  console.log("\n  Setu — Pay for AI with Solana USDC\n");
+
+  const existing = loadWallet();
+  let wallet = existing;
+
+  if (existing) {
+    console.log(`  Existing wallet found: ${existing.publicKey}`);
+    const choice = await prompt("  Use existing wallet? (Y/n): ");
+    if (choice.toLowerCase() === "n") {
+      const action = await prompt("  (g)enerate new or (i)mport existing? ");
+      if (action.toLowerCase() === "i") {
+        const key = await prompt("  Enter Solana private key (base58): ");
+        if (!isValidPrivateKey(key)) {
+          console.error("  Invalid private key.");
+          process.exit(1);
+        }
+        wallet = saveWallet(key);
+        console.log(`  Wallet imported: ${wallet.publicKey}`);
+      } else {
+        wallet = ensureWallet();
+        console.log(`  New wallet generated: ${wallet.publicKey}`);
+      }
+    }
+  } else {
+    const action = await prompt(
+      "  No wallet found. (g)enerate new or (i)mport existing? ",
+    );
+    if (action.toLowerCase() === "i") {
+      const key = await prompt("  Enter Solana private key (base58): ");
+      if (!isValidPrivateKey(key)) {
+        console.error("  Invalid private key.");
+        process.exit(1);
+      }
+      wallet = saveWallet(key);
+      console.log(`  Wallet imported: ${wallet.publicKey}`);
+    } else {
+      wallet = ensureWallet();
+      console.log(`  New wallet generated: ${wallet.publicKey}`);
+    }
+  }
+
+  if (!wallet) {
+    console.error("  Failed to set up wallet.");
+    process.exit(1);
+  }
+
+  console.log(`\n  Wallet: ${wallet.publicKey}`);
+  console.log(`  Key stored at: ${getWalletKeyPath()}`);
+
+  await injectConfig();
+  console.log(`  OpenClaw config updated: ${getConfigPath()}`);
+
+  console.log(`
+  Setup complete!
+
+  Next steps:
+    1. Fund your wallet with USDC on Solana:
+       ${wallet.publicKey}
+
+    2. Start the proxy:
+       openclaw-setu start
+
+    3. Restart OpenClaw:
+       openclaw gateway restart
+
+  Your wallet address is your identity — no API keys needed.
+`);
+}
+
+async function cmdWalletGenerate() {
+  const existing = loadWallet();
+  if (existing) {
+    const choice = await prompt(
+      `Wallet exists (${existing.publicKey}). Overwrite? (y/N): `,
+    );
+    if (choice.toLowerCase() !== "y") {
+      console.log("Cancelled.");
+      return;
+    }
+  }
+  const wallet = ensureWallet();
+  console.log(`Wallet generated: ${wallet.publicKey}`);
+  console.log(`Key stored at: ${getWalletKeyPath()}`);
+  console.log(`\nFund with USDC on Solana: ${wallet.publicKey}`);
+}
+
+async function cmdWalletImport() {
+  const key = await prompt("Enter Solana private key (base58): ");
+  if (!isValidPrivateKey(key)) {
+    console.error("Invalid private key.");
+    process.exit(1);
+  }
+  const wallet = saveWallet(key);
+  console.log(`Wallet imported: ${wallet.publicKey}`);
+}
+
+function cmdWalletExport() {
+  const key = exportWalletKey();
+  if (!key) {
+    console.error("No wallet found. Run `openclaw-setu setup` first.");
+    process.exit(1);
+  }
+  console.log(key);
+}
+
+async function cmdWalletInfo() {
+  const wallet = loadWallet();
+  if (!wallet) {
+    console.error("No wallet found. Run `openclaw-setu setup` first.");
+    process.exit(1);
+  }
+
+  console.log(`\nWallet: ${wallet.publicKey}`);
+  console.log(`Key path: ${getWalletKeyPath()}`);
+
+  console.log("\nFetching balances...");
+  const balances = await getSetuBalance(wallet.privateKey);
+
+  if (balances.setu) {
+    console.log(`\nSetu Balance: $${balances.setu.balance.toFixed(4)}`);
+    console.log(`Total Spent:  $${balances.setu.totalSpent.toFixed(4)}`);
+    console.log(`Requests:     ${balances.setu.requestCount}`);
+  } else {
+    console.log("\nSetu Balance: (not available — wallet may not be registered yet)");
+  }
+
+  if (balances.wallet) {
+    console.log(
+      `\nOn-chain USDC: $${balances.wallet.usdcBalance.toFixed(4)} (${balances.wallet.network})`,
+    );
+  }
+}
+
+async function cmdConfigInject() {
+  await injectConfig();
+  console.log(`Setu provider injected into ${getConfigPath()}`);
+}
+
+function cmdConfigRemove() {
+  removeConfig();
+  console.log(`Setu provider removed from ${getConfigPath()}`);
+}
+
+function cmdConfigStatus() {
+  if (isConfigured()) {
+    console.log(`Setu is configured in ${getConfigPath()}`);
+  } else {
+    console.log("Setu is not configured. Run `openclaw-setu setup`.");
+  }
+}
+
+function cmdStart() {
+  const port = parseInt(process.env.SETU_PROXY_PORT ?? "8403", 10);
+  const verbose = process.argv.includes("--verbose") || process.argv.includes("-v");
+
+  try {
+    const { wallet } = createProxy({ port, verbose });
+    console.log(`\nSetu proxy running on http://localhost:${port}`);
+    console.log(`Wallet: ${wallet.publicKey}`);
+    console.log(`\nPress Ctrl+C to stop.\n`);
+  } catch (err) {
+    console.error((err as Error).message);
+    process.exit(1);
+  }
+}
+
+const [cmd, sub] = process.argv.slice(2);
+
+switch (cmd) {
+  case "setup":
+    cmdSetup();
+    break;
+  case "start":
+    cmdStart();
+    break;
+  case "wallet":
+    switch (sub) {
+      case "generate":
+        cmdWalletGenerate();
+        break;
+      case "import":
+        cmdWalletImport();
+        break;
+      case "export":
+        cmdWalletExport();
+        break;
+      case "info":
+        cmdWalletInfo();
+        break;
+      default:
+        console.error('Unknown wallet command. Use: generate, import, export, info');
+        process.exit(1);
+    }
+    break;
+  case "config":
+    switch (sub) {
+      case "inject":
+        cmdConfigInject();
+        break;
+      case "remove":
+        cmdConfigRemove();
+        break;
+      case "status":
+        cmdConfigStatus();
+        break;
+      default:
+        console.error("Unknown config command. Use: inject, remove, status");
+        process.exit(1);
+    }
+    break;
+  case "help":
+  case "--help":
+  case "-h":
+  case undefined:
+    printHelp();
+    break;
+  default:
+    console.error(`Unknown command: ${cmd}`);
+    printHelp();
+    process.exit(1);
+}

package/src/config.ts

@@ -0,0 +1,270 @@
+import { readFileSync, writeFileSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import type { ModelApi } from "./types.ts";
+
+const OPENCLAW_DIR = join(homedir(), ".openclaw");
+const OPENCLAW_CONFIG_PATH = join(OPENCLAW_DIR, "openclaw.json");
+
+const PROVIDER_KEY = "setu";
+const DEFAULT_PROXY_PORT = 8403;
+const DEFAULT_BASE_URL = "https://api.setu.ottocode.io";
+
+export interface SetuModelConfig {
+  id: string;
+  name: string;
+  api?: ModelApi;
+  reasoning?: boolean;
+  input?: Array<"text" | "image">;
+  contextWindow?: number;
+  maxTokens?: number;
+}
+
+export interface SetuProviderConfig {
+  baseUrl: string;
+  apiKey: string;
+  api: ModelApi;
+  authHeader: boolean;
+  models: SetuModelConfig[];
+}
+
+function readOpenClawConfig(): Record<string, unknown> {
+  if (!existsSync(OPENCLAW_CONFIG_PATH)) return {};
+  try {
+    return JSON.parse(readFileSync(OPENCLAW_CONFIG_PATH, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+
+function writeOpenClawConfig(config: Record<string, unknown>): void {
+  writeFileSync(OPENCLAW_CONFIG_PATH, JSON.stringify(config, null, 2) + "\n");
+}
+
+interface CatalogModel {
+  id: string;
+  owned_by: string;
+  context_length: number;
+  max_output: number;
+  capabilities?: { tool_call?: boolean; reasoning?: boolean };
+}
+
+function apiForOwner(owner: string): ModelApi {
+  switch (owner) {
+    case "anthropic":
+      return "anthropic-messages";
+    case "google":
+      return "google-generative-ai";
+    default:
+      return "openai-completions";
+  }
+}
+
+function displayName(id: string, owner: string): string {
+  return `${id} (${owner}, via Setu)`;
+}
+
+export async function fetchModelsFromCatalog(
+  baseURL: string = DEFAULT_BASE_URL,
+): Promise<SetuModelConfig[]> {
+  try {
+    const resp = await fetch(`${baseURL}/v1/models`);
+    if (!resp.ok) return getDefaultModels();
+    const data = (await resp.json()) as { data: CatalogModel[] };
+    return data.data.map((m) => ({
+      id: m.id,
+      name: displayName(m.id, m.owned_by),
+      api: apiForOwner(m.owned_by),
+      reasoning: m.capabilities?.reasoning ?? false,
+      input: ["text"] as Array<"text" | "image">,
+      contextWindow: m.context_length,
+      maxTokens: m.max_output,
+    }));
+  } catch {
+    return getDefaultModels();
+  }
+}
+
+export function getDefaultModels(): SetuModelConfig[] {
+  return [
+    {
+      id: "claude-sonnet-4-6",
+      name: "Claude Sonnet 4.6 (anthropic, via Setu)",
+      api: "anthropic-messages",
+      reasoning: true,
+      input: ["text", "image"],
+      contextWindow: 200000,
+      maxTokens: 64000,
+    },
+    {
+      id: "claude-sonnet-4-5",
+      name: "Claude Sonnet 4.5 (anthropic, via Setu)",
+      api: "anthropic-messages",
+      reasoning: true,
+      input: ["text", "image"],
+      contextWindow: 200000,
+      maxTokens: 64000,
+    },
+    {
+      id: "claude-opus-4-6",
+      name: "Claude Opus 4.6 (anthropic, via Setu)",
+      api: "anthropic-messages",
+      reasoning: true,
+      input: ["text", "image"],
+      contextWindow: 200000,
+      maxTokens: 128000,
+    },
+    {
+      id: "claude-3-5-haiku-20241022",
+      name: "Claude 3.5 Haiku (anthropic, via Setu)",
+      api: "anthropic-messages",
+      reasoning: false,
+      input: ["text", "image"],
+      contextWindow: 200000,
+      maxTokens: 8192,
+    },
+    {
+      id: "gpt-5.1-codex",
+      name: "GPT-5.1 Codex (openai, via Setu)",
+      api: "openai-completions",
+      reasoning: true,
+      input: ["text", "image"],
+      contextWindow: 400000,
+      maxTokens: 128000,
+    },
+    {
+      id: "gpt-5",
+      name: "GPT-5 (openai, via Setu)",
+      api: "openai-completions",
+      reasoning: true,
+      input: ["text", "image"],
+      contextWindow: 400000,
+      maxTokens: 128000,
+    },
+    {
+      id: "gpt-5-mini",
+      name: "GPT-5 Mini (openai, via Setu)",
+      api: "openai-completions",
+      reasoning: true,
+      input: ["text", "image"],
+      contextWindow: 400000,
+      maxTokens: 128000,
+    },
+    {
+      id: "codex-mini-latest",
+      name: "Codex Mini (openai, via Setu)",
+      api: "openai-completions",
+      reasoning: true,
+      input: ["text"],
+      contextWindow: 200000,
+      maxTokens: 100000,
+    },
+    {
+      id: "gemini-3-pro-preview",
+      name: "Gemini 3 Pro (google, via Setu)",
+      api: "openai-completions",
+      reasoning: true,
+      input: ["text", "image"],
+      contextWindow: 1000000,
+      maxTokens: 64000,
+    },
+    {
+      id: "gemini-3-flash-preview",
+      name: "Gemini 3 Flash (google, via Setu)",
+      api: "openai-completions",
+      reasoning: true,
+      input: ["text", "image"],
+      contextWindow: 1048576,
+      maxTokens: 65536,
+    },
+    {
+      id: "kimi-k2.5",
+      name: "Kimi K2.5 (moonshot, via Setu)",
+      api: "openai-completions",
+      reasoning: true,
+      input: ["text"],
+      contextWindow: 262144,
+      maxTokens: 262144,
+    },
+    {
+      id: "glm-5",
+      name: "GLM-5 (zai, via Setu)",
+      api: "openai-completions",
+      reasoning: true,
+      input: ["text"],
+      contextWindow: 204800,
+      maxTokens: 131072,
+    },
+    {
+      id: "MiniMax-M2.5",
+      name: "MiniMax M2.5 (minimax, via Setu)",
+      api: "openai-completions",
+      reasoning: true,
+      input: ["text"],
+      contextWindow: 204800,
+      maxTokens: 131072,
+    },
+  ];
+}
+
+export function buildProviderConfig(
+  port: number = DEFAULT_PROXY_PORT,
+): SetuProviderConfig {
+  return {
+    baseUrl: `http://localhost:${port}/v1`,
+    apiKey: "setu-proxy-handles-auth",
+    api: "openai-completions",
+    authHeader: false,
+    models: getDefaultModels(),
+  };
+}
+
+export async function buildProviderConfigWithCatalog(
+  port: number = DEFAULT_PROXY_PORT,
+  baseURL: string = DEFAULT_BASE_URL,
+): Promise<SetuProviderConfig> {
+  const models = await fetchModelsFromCatalog(baseURL);
+  return {
+    baseUrl: `http://localhost:${port}/v1`,
+    apiKey: "setu-proxy-handles-auth",
+    api: "openai-completions",
+    authHeader: false,
+    models,
+  };
+}
+
+export async function injectConfig(port: number = DEFAULT_PROXY_PORT): Promise<void> {
+  const config = readOpenClawConfig();
+
+  if (!config.models) config.models = {};
+  const models = config.models as Record<string, unknown>;
+  if (!models.providers) models.providers = {};
+  const providers = models.providers as Record<string, unknown>;
+
+  providers[PROVIDER_KEY] = await buildProviderConfigWithCatalog(port);
+
+  writeOpenClawConfig(config);
+}
+
+export function removeConfig(): void {
+  const config = readOpenClawConfig();
+
+  const models = config.models as Record<string, unknown> | undefined;
+  if (!models?.providers) return;
+  const providers = models.providers as Record<string, unknown>;
+  delete providers[PROVIDER_KEY];
+
+  writeOpenClawConfig(config);
+}
+
+export function isConfigured(): boolean {
+  const config = readOpenClawConfig();
+  const models = config.models as Record<string, unknown> | undefined;
+  if (!models?.providers) return false;
+  const providers = models.providers as Record<string, unknown>;
+  return PROVIDER_KEY in providers;
+}
+
+export function getConfigPath(): string {
+  return OPENCLAW_CONFIG_PATH;
+}

package/src/index.ts

@@ -0,0 +1,197 @@
+import type {
+  OpenClawPluginDefinition,
+  OpenClawPluginApi,
+  OpenClawPluginCommandDefinition,
+} from "./types.ts";
+import {
+  loadWallet,
+  ensureWallet,
+  getSetuBalance,
+  getWalletKeyPath,
+} from "./wallet.ts";
+import {
+  buildProviderConfig,
+  injectConfig,
+  isConfigured,
+} from "./config.ts";
+import { isValidPrivateKey } from "@ottocode/ai-sdk";
+
+const DEFAULT_PORT = 8403;
+
+function getPort(api: OpenClawPluginApi): number {
+  const cfg = api.pluginConfig as Record<string, unknown> | undefined;
+  return (cfg?.port as number) ?? DEFAULT_PORT;
+}
+
+const plugin: OpenClawPluginDefinition = {
+  id: "setu",
+  name: "Setu",
+  description: "Pay for AI with Solana USDC — no API keys, just a wallet.",
+  version: "0.1.0",
+
+  async register(api: OpenClawPluginApi) {
+    const port = getPort(api);
+
+    api.registerProvider({
+      id: "setu",
+      label: "Setu (Solana USDC)",
+      aliases: ["setu-solana"],
+      envVars: ["SETU_PRIVATE_KEY"],
+      models: buildProviderConfig(port),
+      auth: [
+        {
+          id: "setu-wallet",
+          label: "Solana Wallet",
+          hint: "Generate or import a Solana wallet — pay per token with USDC",
+          kind: "custom",
+          async run(ctx) {
+            const existing = loadWallet();
+
+            if (existing) {
+              ctx.prompter.note(
+                `Existing Setu wallet found: ${existing.publicKey}`,
+              );
+              return {
+                profiles: [
+                  {
+                    profileId: "setu-wallet",
+                    credential: {
+                      apiKey: "setu-proxy-handles-auth",
+                      type: "wallet",
+                      walletAddress: existing.publicKey,
+                    },
+                  },
+                ],
+                configPatch: {
+                  models: { providers: { setu: buildProviderConfig(port) } },
+                },
+                defaultModel: `setu/claude-sonnet-4-6`,
+                notes: [
+                  `Wallet: ${existing.publicKey}`,
+                  `Fund with USDC on Solana to start using.`,
+                  `Run \`openclaw-setu start\` to start the proxy.`,
+                ],
+              };
+            }
+
+            const keyInput = await ctx.prompter.text({
+              message:
+                "Enter Solana private key (base58) or press Enter to generate a new one:",
+              validate: (value: string) => {
+                if (value && !isValidPrivateKey(value)) {
+                  return "Invalid Solana private key";
+                }
+                return undefined;
+              },
+            });
+
+            const key = typeof keyInput === "string" ? keyInput : "";
+            const wallet = key ? ensureWallet() : ensureWallet();
+            if (key && isValidPrivateKey(key)) {
+              const { saveWallet } = await import("./wallet.ts");
+              saveWallet(key);
+            }
+
+            const finalWallet = loadWallet()!;
+
+            await injectConfig(port);
+
+            return {
+              profiles: [
+                {
+                  profileId: "setu-wallet",
+                  credential: {
+                    apiKey: "setu-proxy-handles-auth",
+                    type: "wallet",
+                    walletAddress: finalWallet.publicKey,
+                  },
+                },
+              ],
+              configPatch: {
+                models: { providers: { setu: buildProviderConfig(port) } },
+              },
+              defaultModel: `setu/claude-sonnet-4-6`,
+              notes: [
+                `Wallet generated: ${finalWallet.publicKey}`,
+                `Key stored at: ${getWalletKeyPath()}`,
+                `Fund with USDC on Solana: ${finalWallet.publicKey}`,
+                `Run \`openclaw-setu start\` to start the proxy.`,
+              ],
+            };
+          },
+        },
+      ],
+    });
+
+    const walletCmd: OpenClawPluginCommandDefinition = {
+      name: "wallet",
+      description: "Show your Setu wallet address and balances",
+      requireAuth: true,
+      async handler() {
+        const wallet = loadWallet();
+        if (!wallet) {
+          return { text: "No Setu wallet found. Run `openclaw-setu setup`." };
+        }
+
+        const balances = await getSetuBalance(wallet.privateKey);
+        const lines = [`Wallet: ${wallet.publicKey}`];
+
+        if (balances.setu) {
+          lines.push(`Setu Balance: $${balances.setu.balance.toFixed(4)}`);
+          lines.push(`Total Spent: $${balances.setu.totalSpent.toFixed(4)}`);
+          lines.push(`Requests: ${balances.setu.requestCount}`);
+        }
+        if (balances.wallet) {
+          lines.push(
+            `On-chain USDC: $${balances.wallet.usdcBalance.toFixed(4)} (${balances.wallet.network})`,
+          );
+        }
+
+        return { text: lines.join("\n") };
+      },
+    };
+
+    api.registerCommand(walletCmd);
+
+    const statusCmd: OpenClawPluginCommandDefinition = {
+      name: "setu-status",
+      description: "Check Setu plugin configuration status",
+      async handler() {
+        const wallet = loadWallet();
+        const configured = isConfigured();
+        const lines = [
+          `Wallet: ${wallet ? wallet.publicKey : "not set up"}`,
+          `OpenClaw config: ${configured ? "injected" : "not configured"}`,
+          `Proxy port: ${port}`,
+        ];
+        return { text: lines.join("\n") };
+      },
+    };
+
+    api.registerCommand(statusCmd);
+
+    api.registerService({
+      id: "setu-proxy",
+      async start() {
+        const wallet = loadWallet();
+        if (!wallet) {
+          api.logger.warn(
+            "Setu: No wallet found. Run `openclaw-setu setup` first.",
+          );
+          return;
+        }
+        try {
+          const { createProxy } = await import("./proxy.ts");
+          createProxy({ port, verbose: false });
+          api.logger.info(
+            `Setu proxy running on http://localhost:${port}`,
+          );
+        } catch (err) {
+          api.logger.error(`Setu proxy failed: ${(err as Error).message}`);
+        }
+      },
+    });
+  },
+};
+
+export default plugin;

package/src/proxy.ts

@@ -0,0 +1,149 @@
+import { createSetuFetch, createWalletContext } from "@ottocode/ai-sdk";
+import { loadWallet } from "./wallet.ts";
+
+const DEFAULT_PORT = 8403;
+const DEFAULT_BASE_URL = "https://api.setu.ottocode.io";
+
+export interface ProxyOptions {
+  port?: number;
+  baseURL?: string;
+  verbose?: boolean;
+}
+
+export function createProxy(options: ProxyOptions = {}) {
+  const port = options.port ?? DEFAULT_PORT;
+  const baseURL = options.baseURL ?? DEFAULT_BASE_URL;
+  const verbose = options.verbose ?? false;
+
+  const wallet = loadWallet();
+  if (!wallet) {
+    throw new Error(
+      "No wallet found. Run `openclaw-setu setup` or `openclaw-setu wallet generate` first.",
+    );
+  }
+
+  const log = verbose
+    ? (msg: string) => console.log(`[setu-proxy] ${msg}`)
+    : (_msg: string) => {};
+
+  const walletCtx = createWalletContext({ privateKey: wallet.privateKey });
+
+  const setuFetch = createSetuFetch({
+    wallet: walletCtx,
+    baseURL,
+    callbacks: {
+      onPaymentRequired: (amountUsd) => {
+        log(`Payment required: $${amountUsd.toFixed(4)}`);
+      },
+      onPaymentComplete: (data) => {
+        log(
+          `Payment complete: $${data.amountUsd.toFixed(4)} | balance: $${data.newBalance.toFixed(4)}`,
+        );
+      },
+      onPaymentError: (error) => {
+        console.error(`[setu-proxy] Payment error: ${error}`);
+      },
+      onBalanceUpdate: (update) => {
+        log(
+          `Cost: $${update.costUsd.toFixed(4)} | remaining: $${update.balanceRemaining.toFixed(4)}`,
+        );
+      },
+    },
+  });
+
+  const proxyBaseURL = baseURL;
+
+  const server = Bun.serve({
+    port,
+    async fetch(req: Request): Promise<Response> {
+      const url = new URL(req.url);
+
+      if (url.pathname === "/health") {
+        return Response.json({
+          status: "ok",
+          wallet: wallet.publicKey,
+          provider: "setu",
+        });
+      }
+
+      if (url.pathname === "/v1/models") {
+        log("GET /v1/models");
+        const resp = await setuFetch(`${proxyBaseURL}/v1/models`, {
+          method: "GET",
+          headers: { "Content-Type": "application/json" },
+        });
+        return new Response(resp.body, {
+          status: resp.status,
+          headers: {
+            "Content-Type":
+              resp.headers.get("Content-Type") ?? "application/json",
+            "Access-Control-Allow-Origin": "*",
+          },
+        });
+      }
+
+      const isCompletions = url.pathname === "/v1/chat/completions";
+      const isResponses = url.pathname === "/v1/responses";
+      if (!isCompletions && !isResponses) {
+        const targetURL = `${proxyBaseURL}${url.pathname}`;
+        log(`Proxying ${req.method} ${url.pathname}`);
+        const resp = await setuFetch(targetURL, {
+          method: req.method,
+          headers: { "Content-Type": "application/json" },
+          body: req.method !== "GET" ? await req.text() : undefined,
+        });
+        return new Response(resp.body, {
+          status: resp.status,
+          headers: {
+            "Content-Type":
+              resp.headers.get("Content-Type") ?? "application/json",
+            "Access-Control-Allow-Origin": "*",
+          },
+        });
+      }
+
+      const body = await req.text();
+      let parsed: Record<string, unknown> = {};
+      try {
+        parsed = JSON.parse(body);
+      } catch {
+        return Response.json({ error: "Invalid JSON body" }, { status: 400 });
+      }
+
+      const model = parsed.model as string;
+      const stream = parsed.stream as boolean;
+      log(
+        `${isCompletions ? "POST /v1/chat/completions" : "POST /v1/responses"} model=${model} stream=${stream}`,
+      );
+
+      const targetURL = `${proxyBaseURL}${url.pathname}`;
+      const resp = await setuFetch(targetURL, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body,
+      });
+
+      if (stream && resp.body) {
+        return new Response(resp.body, {
+          status: resp.status,
+          headers: {
+            "Content-Type": "text/event-stream",
+            "Cache-Control": "no-cache",
+            Connection: "keep-alive",
+            "Access-Control-Allow-Origin": "*",
+          },
+        });
+      }
+
+      return new Response(resp.body, {
+        status: resp.status,
+        headers: {
+          "Content-Type": "application/json",
+          "Access-Control-Allow-Origin": "*",
+        },
+      });
+    },
+  });
+
+  return { server, port, wallet };
+}

package/src/types.ts

@@ -0,0 +1,154 @@
+export type ModelApi =
+  | "openai-completions"
+  | "openai-responses"
+  | "anthropic-messages"
+  | "google-generative-ai"
+  | "github-copilot"
+  | "bedrock-converse-stream";
+
+export type ModelDefinitionConfig = {
+  id: string;
+  name: string;
+  api?: ModelApi;
+  reasoning?: boolean;
+  input?: Array<"text" | "image">;
+  cost?: {
+    input: number;
+    output: number;
+    cacheRead?: number;
+    cacheWrite?: number;
+  };
+  contextWindow?: number;
+  maxTokens?: number;
+  headers?: Record<string, string>;
+};
+
+export type ModelProviderConfig = {
+  baseUrl: string;
+  apiKey?: string;
+  api?: ModelApi;
+  headers?: Record<string, string>;
+  authHeader?: boolean;
+  models: ModelDefinitionConfig[];
+};
+
+export type AuthProfileCredential = {
+  apiKey?: string;
+  type?: string;
+  [key: string]: unknown;
+};
+
+export type ProviderAuthResult = {
+  profiles: Array<{ profileId: string; credential: AuthProfileCredential }>;
+  configPatch?: Record<string, unknown>;
+  defaultModel?: string;
+  notes?: string[];
+};
+
+export type WizardPrompter = {
+  text: (opts: {
+    message: string;
+    validate?: (value: string) => string | undefined;
+  }) => Promise<string | symbol>;
+  note: (message: string) => void;
+  progress: (message: string) => { stop: (message?: string) => void };
+};
+
+export type ProviderAuthContext = {
+  config: Record<string, unknown>;
+  agentDir?: string;
+  workspaceDir?: string;
+  prompter: WizardPrompter;
+  runtime: { log: (message: string) => void };
+  isRemote: boolean;
+  openUrl: (url: string) => Promise<void>;
+};
+
+export type ProviderAuthMethod = {
+  id: string;
+  label: string;
+  hint?: string;
+  kind: "oauth" | "api_key" | "token" | "device_code" | "custom";
+  run: (ctx: ProviderAuthContext) => Promise<ProviderAuthResult>;
+};
+
+export type ProviderPlugin = {
+  id: string;
+  label: string;
+  docsPath?: string;
+  aliases?: string[];
+  envVars?: string[];
+  models?: ModelProviderConfig;
+  auth: ProviderAuthMethod[];
+  formatApiKey?: (cred: AuthProfileCredential) => string;
+};
+
+export type PluginLogger = {
+  debug?: (message: string) => void;
+  info: (message: string) => void;
+  warn: (message: string) => void;
+  error: (message: string) => void;
+};
+
+export type OpenClawPluginService = {
+  id: string;
+  start: () => void | Promise<void>;
+  stop?: () => void | Promise<void>;
+};
+
+export type OpenClawPluginApi = {
+  id: string;
+  name: string;
+  version?: string;
+  description?: string;
+  source: string;
+  config: Record<string, unknown> & {
+    models?: { providers?: Record<string, ModelProviderConfig> };
+    agents?: Record<string, unknown>;
+  };
+  pluginConfig?: Record<string, unknown>;
+  logger: PluginLogger;
+  registerProvider: (provider: ProviderPlugin) => void;
+  registerTool: (tool: unknown, opts?: unknown) => void;
+  registerHook: (events: string | string[], handler: unknown, opts?: unknown) => void;
+  registerHttpRoute: (params: { path: string; handler: unknown }) => void;
+  registerService: (service: OpenClawPluginService) => void;
+  registerCommand: (command: unknown) => void;
+  resolvePath: (input: string) => string;
+  on: (hookName: string, handler: unknown, opts?: unknown) => void;
+};
+
+export type OpenClawPluginDefinition = {
+  id?: string;
+  name?: string;
+  description?: string;
+  version?: string;
+  register?: (api: OpenClawPluginApi) => void | Promise<void>;
+  activate?: (api: OpenClawPluginApi) => void | Promise<void>;
+};
+
+export type PluginCommandContext = {
+  senderId?: string;
+  channel: string;
+  isAuthorizedSender: boolean;
+  args?: string;
+  commandBody: string;
+  config: Record<string, unknown>;
+};
+
+export type PluginCommandResult = {
+  text?: string;
+  isError?: boolean;
+};
+
+export type PluginCommandHandler = (
+  ctx: PluginCommandContext,
+) => PluginCommandResult | Promise<PluginCommandResult>;
+
+export type OpenClawPluginCommandDefinition = {
+  name: string;
+  description: string;
+  acceptsArgs?: boolean;
+  requireAuth?: boolean;
+  handler: PluginCommandHandler;
+};

package/src/wallet.ts

@@ -0,0 +1,79 @@
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import {
+  generateWallet,
+  importWallet,
+  isValidPrivateKey,
+  fetchBalance,
+  fetchWalletUsdcBalance,
+} from "@ottocode/ai-sdk";
+import type { WalletInfo } from "@ottocode/ai-sdk";
+
+const WALLET_DIR = join(homedir(), ".openclaw", "setu");
+const WALLET_KEY_PATH = join(WALLET_DIR, "wallet.key");
+
+export function getWalletKeyPath(): string {
+  return WALLET_KEY_PATH;
+}
+
+export function loadWallet(): WalletInfo | null {
+  try {
+    if (!existsSync(WALLET_KEY_PATH)) return null;
+    const privateKey = readFileSync(WALLET_KEY_PATH, "utf-8").trim();
+    if (!isValidPrivateKey(privateKey)) return null;
+    return importWallet(privateKey);
+  } catch {
+    return null;
+  }
+}
+
+export function saveWallet(privateKey: string): WalletInfo {
+  if (!isValidPrivateKey(privateKey)) {
+    throw new Error("Invalid Solana private key");
+  }
+  const wallet = importWallet(privateKey);
+  mkdirSync(WALLET_DIR, { recursive: true });
+  writeFileSync(WALLET_KEY_PATH, privateKey, { mode: 0o600 });
+  return wallet;
+}
+
+export function ensureWallet(): WalletInfo {
+  const existing = loadWallet();
+  if (existing) return existing;
+  const wallet = generateWallet();
+  saveWallet(wallet.privateKey);
+  return wallet;
+}
+
+export function exportWalletKey(): string | null {
+  try {
+    if (!existsSync(WALLET_KEY_PATH)) return null;
+    return readFileSync(WALLET_KEY_PATH, "utf-8").trim();
+  } catch {
+    return null;
+  }
+}
+
+export async function getSetuBalance(privateKey: string): Promise<{
+  setu: { balance: number; totalSpent: number; requestCount: number } | null;
+  wallet: { usdcBalance: number; network: string } | null;
+}> {
+  const [setu, wallet] = await Promise.all([
+    fetchBalance({ privateKey }),
+    fetchWalletUsdcBalance({ privateKey }),
+  ]);
+
+  return {
+    setu: setu
+      ? {
+          balance: setu.balance,
+          totalSpent: setu.totalSpent,
+          requestCount: setu.requestCount,
+        }
+      : null,
+    wallet: wallet
+      ? { usdcBalance: wallet.usdcBalance, network: wallet.network }
+      : null,
+  };
+}