open-agents-ai 0.184.4 → 0.184.6

package/README.md

@@ -109,6 +109,7 @@ The agent uses tools autonomously in a loop — reading errors, fixing code, and
 - **Task templates** — specialized system prompts and tool recommendations for code, document, analysis, plan tasks
 - **Inference capability scoring** — canirun.ai-style hardware assessment at first launch: memory/compute/speed scores, per-model compatibility matrix, recommended model selection
 - **Auto-install everything** — first-run wizard auto-installs Ollama, curl, Python3, python3-venv with platform-aware package managers (apt, dnf, yum, pacman, apk, zypper, brew)
+- **Sponsored inference** — `/sponsor` walks through a 5-step wizard to share your GPU with the world: select endpoints, choose banner animation (8 presets + AI-generated custom), set header message/links, configure transport (cloudflared/libp2p) + rate limits, and go live. Consumers discover sponsors via `/endpoint sponsor`. Secure proxy relay with per-IP rate limiting, daily token budgets, model allowlist, and concurrent request caps. Sponsor's raw API URL is never exposed. See [Sponsored Inference](#sponsored-inference--share-your-gpu-with-the-world) below
 - **P2P inference network** — `/expose` local models or forward any `/endpoint` (Chutes, Groq, OpenRouter, etc.) through the libp2p P2P mesh. Passthrough mode (`/expose passthrough`) relays upstream API requests; `--loadbalance` distributes rate-limited token budgets across peers. `/expose config` provides an arrow-key menu for all settings. Gateway stats show budget remaining from `x-ratelimit-*` headers. Background daemon persists across OA restarts
 - **P2P mesh networking** — `/p2p` with secret-safe variable placeholders (`{{OA_VAR_*}}`), trust tiers (LOCAL/TEE/VERIFIED/PUBLIC), WebSocket peer mesh, and inference routing with automatic secret redaction/injection
 - **Secret vault** — `/secrets` manages API keys and credentials with AES-256-GCM encrypted persistence; secrets are automatically redacted before sending to untrusted inference peers and re-injected on response
@@ -1446,6 +1447,70 @@ nexus(action='budget_set', auto_approve_below='0.01')  # Auto-approve micropayme
 - All outbound messages scanned for key material before sending
 - Keys NEVER appear in tool output, logs, or LLM context
 
+## Sponsored Inference — Share Your GPU With the World
+
+Anyone running Open Agents can become an inference sponsor — sharing their local models (or forwarded cloud endpoints) with users worldwide through a secure, branded relay.
+
+### For Sponsors: `/sponsor`
+
+Run `/sponsor` to walk through the 5-step onboarding wizard:
+
+```
+Step 1 → Select endpoints (auto-discovers local Ollama models + configured /endpoints)
+Step 2 → Choose banner animation (8 presets: wave, pulse, matrix, sparkle, radar, circuit, fire)
+         or generate a custom animation with your local LLM
+Step 3 → Set header message + clickable link (displayed to consumers during inference)
+Step 4 → Configure transport (cloudflared tunnel and/or libp2p P2P mesh)
+         + rate limits (req/min, tokens/day, max concurrent, model allowlist)
+Step 5 → Review and Go Live
+```
+
+**What happens under the hood:**
+- A secure reverse proxy starts on localhost, forwarding to your backend
+- Bearer token auth gate — unauthenticated requests rejected
+- Per-IP sliding window rate limiting + global daily token budget
+- Model allowlist enforcement (block models you don't want to share)
+- Token usage tracked from both Ollama and OpenAI response formats
+- Cloudflared tunnel creates a public HTTPS URL (or libp2p for decentralized relay)
+- Your raw API endpoint URL is **never exposed** — consumers only see the tunnel URL
+- Config persists to `.oa/sponsor/config.json` — survives restarts
+
+**Management:**
+```bash
+/sponsor          # Dashboard (when active) or wizard (when inactive)
+/sponsor status   # Usage metrics: requests, tokens, active connections, unique users
+/sponsor pause    # Stop serving, keep config
+/sponsor remove   # Retire sponsorship entirely
+```
+
+### For Consumers: `/endpoint sponsor`
+
+Users who need inference can discover and connect to sponsors:
+
+```bash
+/endpoint sponsor          # Browse available sponsored endpoints
+                           # Arrow-key select → auto-configures as active endpoint
+/endpoint <url> --auth <key>  # Direct connection with shared credentials
+```
+
+When using sponsored inference, the sponsor's banner animation and message appear in your header area.
+
+### Architecture
+
+```
+Consumer OA ──→ Cloudflared Tunnel ──→ Sponsor Proxy ──→ Ollama/vLLM
+                (HTTPS)                (auth + rate limit)   (local)
+                                       │
+                                       ├─ Bearer token gate
+                                       ├─ Per-IP sliding window (N req/min)
+                                       ├─ Daily token budget tracking
+                                       ├─ Model allowlist enforcement
+                                       ├─ Concurrent request cap
+                                       └─ Response header sanitization
+```
+
+The tunnel fix uses debounced restarts with exponential cooldown (10s → 20s → 40s), stopping auto-restart after 3 consecutive failures to prevent Cloudflare rate limiting. Progress indicators emit every 5 seconds during startup, and specific error messages are shown for common failure modes (ENOENT, port conflict, 429, DNS).
+
 ## Dream Mode — Creative Idle Exploration
 
 When you're not actively tasking the agent, Dream Mode lets it creatively explore your codebase and generate improvement proposals autonomously. The system models real human sleep architecture with four stages per cycle:

package/dist/index.js

@@ -48801,6 +48801,10 @@ async function handleEndpoint(arg, ctx, local = false) {
     }
     return;
   }
+  if (arg === "sponsor" || arg === "sponsored") {
+    await handleSponsoredEndpoint(ctx, local);
+    return;
+  }
   const normalizedArg = arg.replace(/\u2014/g, "--").replace(/\u2013/g, "--");
   const parts = normalizedArg.split(/\s+/);
   const url = parts[0];
@@ -48961,6 +48965,106 @@ async function handleEndpoint(arg, ctx, local = false) {
     renderWarning(`Could not verify model availability on ${provider.label}. If inference fails, use /model to switch.`);
   }
 }
+async function handleSponsoredEndpoint(ctx, local) {
+  process.stdout.write(`
+  ${c2.dim("Scanning for sponsored inference endpoints...")}
+
+`);
+  const sponsors = [];
+  const gateway = ctx.getExposeGateway?.();
+  if (gateway && gateway.isActive && gateway.tunnelUrl) {
+    sponsors.push({
+      name: "Local Gateway",
+      url: gateway.tunnelUrl,
+      authKey: gateway.authKey,
+      models: [],
+      // would need to probe
+      limits: { rpm: 60, tpd: 1e5 },
+      source: "local"
+    });
+  }
+  const sponsorDir2 = join58(ctx.repoRoot ?? process.cwd(), ".oa", "sponsor");
+  const knownFile = join58(sponsorDir2, "known-sponsors.json");
+  try {
+    if (existsSync42(knownFile)) {
+      const saved = JSON.parse(readFileSync31(knownFile, "utf8"));
+      for (const s of saved) {
+        try {
+          const probe = await fetch(`${s.url}/api/tags`, {
+            headers: s.authKey ? { Authorization: `Bearer ${s.authKey}` } : {},
+            signal: AbortSignal.timeout(5e3)
+          });
+          if (probe.ok) {
+            const data = await probe.json();
+            s.models = (data.models || []).map((m) => m.name);
+            sponsors.push(s);
+          }
+        } catch {
+        }
+      }
+    }
+  } catch {
+  }
+  if (sponsors.length === 0) {
+    renderInfo("No sponsored endpoints found.");
+    renderInfo("");
+    renderInfo("To connect to a sponsor, use:");
+    renderInfo("  /endpoint <tunnel-url> --auth <key>");
+    renderInfo("");
+    renderInfo("Or add a known sponsor URL:");
+    renderInfo("  /endpoint sponsor add <url> --auth <key>");
+    return;
+  }
+  const items = [
+    { key: "hdr", label: "Available Sponsored Endpoints" }
+  ];
+  for (const sp of sponsors) {
+    const modelList = sp.models.length > 0 ? sp.models.slice(0, 3).join(", ") + (sp.models.length > 3 ? ` +${sp.models.length - 3}` : "") : "probing...";
+    items.push({
+      key: sp.url,
+      label: `  ${sp.name} (${sp.source})`,
+      detail: `  Models: ${modelList}  |  ${sp.limits.rpm} req/min, ${sp.limits.tpd >= 1e3 ? (sp.limits.tpd / 1e3).toFixed(0) + "K" : sp.limits.tpd} tokens/day`
+    });
+  }
+  items.push({ key: "sep", label: "" });
+  items.push({ key: "add", label: "  + Add sponsor URL manually..." });
+  if (!ctx.rl) {
+    for (const sp of sponsors) {
+      process.stdout.write(`  ${sp.name}: ${sp.url}
+`);
+    }
+    return;
+  }
+  const result = await tuiSelect({
+    items,
+    title: "Sponsored Endpoints",
+    rl: ctx.rl,
+    skipKeys: ["hdr", "sep"],
+    availableRows: ctx.availableContentRows?.()
+  });
+  if (!result.confirmed || !result.key) {
+    renderInfo("Cancelled.");
+    return;
+  }
+  if (result.key === "add") {
+    renderInfo("Use: /endpoint <tunnel-url> --auth <key>");
+    return;
+  }
+  const selected = sponsors.find((s) => s.url === result.key);
+  if (!selected)
+    return;
+  const endpointArg = selected.authKey ? `${selected.url} --auth ${selected.authKey}` : selected.url;
+  await handleEndpoint(endpointArg, ctx, local);
+  try {
+    mkdirSync18(sponsorDir2, { recursive: true });
+    const existing = existsSync42(knownFile) ? JSON.parse(readFileSync31(knownFile, "utf8")) : [];
+    const updated = existing.filter((s) => s.url !== selected.url);
+    updated.push(selected);
+    writeFileSync19(knownFile, JSON.stringify(updated, null, 2), "utf8");
+  } catch {
+  }
+  renderInfo(`Connected to sponsored endpoint: ${selected.name}`);
+}
 async function handlePeerEndpoint(peerId, authKey, ctx, local) {
   process.stdout.write(`
   ${c2.dim("Detected:")} ${c2.bold("libp2p peer")}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "open-agents-ai",
-  "version": "0.184.4",
+  "version": "0.184.6",
   "description": "AI coding agent powered by open-source models (Ollama/vLLM) \u2014 interactive TUI with agentic tool-calling loop",
   "type": "module",
   "main": "./dist/index.js",