mycomesh-consumer 0.9.3 → 0.9.5

package/README.md

@@ -23,6 +23,9 @@ mycomesh-consumer serve           # http://127.0.0.1:8110/v1 (responses, chat/co
 - `balance` shows the deposit.
 - `request "..." [--model gpt-5.5] [--provider SIGNER]` prints the verified answer,
   the fee and the settlement key.
+- `serve` also speaks the Anthropic Messages API (`/v1/messages`) and the Gemini API
+  (`/v1beta/models/{model}:generateContent` / `:streamGenerateContent`), streaming included, for any model
+  on the network. Text only for now: no tool calls yet. `GET /v1/models` returns the model catalog.
 - `serve` runs the local web console at `http://127.0.0.1:8110/` (chat, wallet, deposit and
   withdrawal, request history and disputes, network status) and an OpenAI-compatible endpoint for
   Codex and other clients; set `MYCOMESH_CONSUMER_API_KEY` to require a bearer token. Only pages from

package/networks/mycomesh-v11-sepolia.json

@@ -12,6 +12,83 @@
   "emission_block": 11815544,
   "oracle": "0x5ba28de9415c7bc2d14f3f31a12fbca226e38a8f",
   "oracle_block": 11820984,
+  "models": {
+    "gpt-5.5": {
+      "tier": 1,
+      "vendor": "OpenAI",
+      "name": "GPT-5.5",
+      "reasoning_efforts": [
+        "low",
+        "medium",
+        "high",
+        "xhigh"
+      ],
+      "summary": "OpenAI frontier model; reasoning effort selectable per request (options.reasoning.effort)",
+      "tier_name": "OpenAI frontier",
+      "capabilities": {
+        "input": [
+          "text"
+        ],
+        "output": [
+          "text"
+        ],
+        "streaming": true,
+        "tools": false,
+        "dialects": [
+          "openai-responses",
+          "openai-chat",
+          "anthropic-messages",
+          "gemini-generate-content"
+        ]
+      }
+    },
+    "claude-sonnet-4-6": {
+      "tier": 2,
+      "vendor": "Anthropic",
+      "name": "Claude Sonnet 4.6",
+      "summary": "Anthropic's balanced model for everyday and coding work",
+      "tier_name": "Anthropic Claude",
+      "capabilities": {
+        "input": [
+          "text"
+        ],
+        "output": [
+          "text"
+        ],
+        "streaming": true,
+        "tools": false,
+        "dialects": [
+          "openai-responses",
+          "openai-chat",
+          "anthropic-messages",
+          "gemini-generate-content"
+        ]
+      }
+    },
+    "claude-opus-4-8": {
+      "tier": 2,
+      "vendor": "Anthropic",
+      "name": "Claude Opus 4.8",
+      "summary": "Anthropic's most capable model",
+      "tier_name": "Anthropic Claude",
+      "capabilities": {
+        "input": [
+          "text"
+        ],
+        "output": [
+          "text"
+        ],
+        "streaming": true,
+        "tools": false,
+        "dialects": [
+          "openai-responses",
+          "openai-chat",
+          "anthropic-messages",
+          "gemini-generate-content"
+        ]
+      }
+    }
+  },
   "tiers": {
     "1": {
       "name": "OpenAI frontier",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mycomesh-consumer",
-  "version": "0.9.3",
+  "version": "0.9.5",
   "description": "MycoMesh V11 Consumer: a custodied deposit, relay-blind encrypted requests to any Provider, and a local OpenAI-compatible endpoint.",
   "repository": {
     "type": "git",

package/src/consumer.mjs

@@ -1,7 +1,7 @@
 // V11 Consumer runtime: one custodied deposit, any Provider, relay-blind requests.
 import { readFileSync } from "node:fs";
-import { createServer, request as httpRequest } from "node:http";
-import { request as httpsRequest } from "node:https";
+import { Agent as HttpAgent, createServer, request as httpRequest } from "node:http";
+import { Agent as HttpsAgent, request as httpsRequest } from "node:https";
 import { dirname, resolve } from "node:path";
 import { rootCertificates } from "node:tls";
 import { addressOf, encodeCall } from "./eip712.mjs";
@@ -13,6 +13,8 @@ import { consoleRoutes, localRequestAllowed } from "./console.mjs";
 import { pinnedOptions, splitPin } from "./tlspin.mjs";
 import { compareRank, rankKey, reputation } from "./reputation.mjs";
 import { hashApiKey } from "./tenants.mjs";
+import { anthropicError, anthropicStream, fromAnthropic, fromGemini, geminiError, geminiRoute, geminiStream,
+  toAnthropic, toGemini } from "./dialects.mjs";
 
 const PROVIDER_CACHE_MS = 30_000;
 const RELAY_CACHE_MS = 300_000;
@@ -26,10 +28,19 @@ export function loadNetwork(path) {
   return network;
 }
 
+/**
+ * A fresh connection per request, through an agent of its own: a reused keep-alive socket that the Relay's
+ * edge has just closed fails with ECONNRESET after the request may have been sent, which can only be
+ * reported as outcome unknown. (Only an agent's own createConnection is honoured, hence the pinned one here.)
+ */
 async function tlsOptions(target, ca, pin) {
-  if (target.protocol !== "https:") return {};
-  if (pin) return pinnedOptions(target.href, pin);
-  return ca ? { ca: [...rootCertificates, ca] } : {};
+  if (target.protocol !== "https:") return { agent: new HttpAgent({ keepAlive: false }) };
+  const agent = new HttpsAgent({ keepAlive: false });
+  if (pin) {
+    agent.createConnection = pinnedOptions(target.href, pin).createConnection;
+    return { agent };
+  }
+  return ca ? { agent, ca: [...rootCertificates, ca] } : { agent };
 }
 
 export async function httpJson(url, { method = "GET", body, ca, pin, timeoutMs = 330_000 } = {}) {
@@ -54,7 +65,10 @@ export async function httpJson(url, { method = "GET", body, ca, pin, timeoutMs =
         catch (error) { reject(error); }
       });
     });
-    req.setTimeout(timeoutMs, () => req.destroy(new Error("request timed out")));
+    // A wall-clock deadline, not a socket idle timeout: keep-alive sockets are reused, and an idle timeout
+    // left on one by an earlier short request (a 10 s /providers call) would later cut a long answer.
+    const timer = setTimeout(() => req.destroy(new Error(`request to ${target.host}${target.pathname} timed out after ${timeoutMs / 1000} s`)), timeoutMs);
+    req.on("close", () => clearTimeout(timer));
     req.on("error", reject);
     if (data) req.write(data);
     req.end();
@@ -94,7 +108,10 @@ export async function httpNdjson(url, { body, ca, pin, timeoutMs = 340_000, onLi
         try { resolvePromise({ status: res.statusCode, body: JSON.parse(chunks.join("") || "{}") }); } catch (error) { reject(error); }
       });
     });
-    req.setTimeout(timeoutMs, () => req.destroy(new Error("request timed out")));
+    // A wall-clock deadline, not a socket idle timeout: keep-alive sockets are reused, and an idle timeout
+    // left on one by an earlier short request (a 10 s /providers call) would later cut a long answer.
+    const timer = setTimeout(() => req.destroy(new Error(`request to ${target.host}${target.pathname} timed out after ${timeoutMs / 1000} s`)), timeoutMs);
+    req.on("close", () => clearTimeout(timer));
     req.on("error", reject);
     req.end(data);
   });
@@ -127,6 +144,7 @@ export class Consumer {
   constructor({ network, keyPrivate, maxFee, journalDir, fetchJson = httpJson, streamJson = httpNdjson, now = () => Math.floor(Date.now() / 1000) }) {
     this.streamJson = streamJson;
     this.journalDir = journalDir;
+    this.inFlight = new Map(); // Provider signer -> requests this Consumer has with it now
     this.network = network;
     this.keyPrivate = keyPrivate;
     this.key = addressOf(keyPrivate);
@@ -198,6 +216,11 @@ export class Consumer {
     return providers;
   }
 
+  /** The network's model catalog (manifest "models"): vendor, tier, capabilities. */
+  catalog() {
+    return this.network.models || {};
+  }
+
   async models() {
     const names = new Set();
     for (const relay of await this.relays()) {
@@ -206,8 +229,24 @@ export class Consumer {
     return [...names].sort();
   }
 
-  /** Try Relays in order; fail over only while the request provably was not dispatched. */
-  async request({ endpoint, model, content, maxOutputTokens = 4096, options = {}, provider, onDelta }) {
+  /**
+   * Try Relays and Providers in order; fail over only while the request provably was not dispatched. When
+   * every Provider is busy, wait and try again (a short queue) rather than failing a burst of requests.
+   */
+  async request(args) {
+    const deadline = Date.now() + (this.queueMs ?? 120_000);
+    for (let attempt = 0; ; attempt += 1) {
+      try {
+        return await this.attempt(args);
+      } catch (error) {
+        const busy = error.dispatched === false && [502, 503].includes(error.status);
+        if (!busy || Date.now() > deadline) throw error;
+        await new Promise((resolve) => setTimeout(resolve, Math.min(4_000, 500 * 2 ** attempt) * (0.5 + Math.random())));
+      }
+    }
+  }
+
+  async attempt({ endpoint, model, content, maxOutputTokens = 4096, options = {}, provider, onDelta }) {
     let lastError;
     for (const relay of await this.relays()) {
       let candidates;
@@ -216,9 +255,18 @@ export class Consumer {
           && (!provider || descriptor.provider_signer === provider.toLowerCase()));
       }
       catch (error) { lastError = error; continue; }
-      // What the chain proves ranks first: recent fraud, verified probe failures, reputation; then price.
+      // What the chain proves ranks first (recent fraud, a suspected downgrade, verified probe failures); then
+      // Providers this Consumer is not already keeping busy; then reputation in coarse bands, shuffled within a
+      // band so that many Consumers spread over the network instead of all queueing at its single best Provider.
       const records = await this.reputations().catch(() => ({}));
-      candidates.sort((a, b) => compareRank(rankKey(a, records[a.provider_signer]), rankKey(b, records[b.provider_signer])));
+      const key = (descriptor) => {
+        const [fraud, downgrade, failure, volume] = rankKey(descriptor, records[descriptor.provider_signer]);
+        const busy = (this.inFlight.get(descriptor.provider_signer) || 0) >= Math.max(1, Number(descriptor.capacity) || 1) ? 1 : 0;
+        return [fraud, downgrade, busy, failure, -Math.floor(Math.log10(1 - volume)), Math.random()];
+      };
+      const keyed = candidates.map((descriptor) => [key(descriptor), descriptor]);
+      keyed.sort((a, b) => compareRank(a[0], b[0]));
+      candidates = keyed.map(([, descriptor]) => descriptor);
       for (const descriptor of candidates) {
         const prepared = prepareRequest({
           descriptor, deployment: this.deployment, keyPrivate: this.keyPrivate, relaySigner: relay.signer,
@@ -227,6 +275,8 @@ export class Consumer {
         let reply;
         const streamed = [];
         let final = null;
+        const signer = descriptor.provider_signer;
+        this.inFlight.set(signer, (this.inFlight.get(signer) || 0) + 1);
         try {
           reply = onDelta
             ? await this.streamJson(`${relay.url}/v11/requests`, { body: prepared.payload, ca: this.network.tls_ca, pin: relay.pin, onLine: (line) => {
@@ -241,11 +291,15 @@ export class Consumer {
         } catch (error) {
           // The request may have reached the Relay: never replay it elsewhere.
           throw Object.assign(new Error(`request outcome unknown: ${error.message}`), { code: "outcome_unknown", requestId: prepared.authorization.request_id });
+        } finally {
+          this.inFlight.set(signer, (this.inFlight.get(signer) || 1) - 1);
         }
         if (reply.streamed) {
           if (!final) throw Object.assign(new Error("stream ended without a result"), { code: "outcome_unknown" });
-          if (final.type === "error") throw Object.assign(new Error(final.error), { status: final.status, dispatched: final.dispatched });
-          reply = { status: 200, body: final };
+          // An error before dispatch (a busy Provider, say) is safe to fail over, exactly as without streaming.
+          reply = final.type === "error"
+            ? { status: final.status || 502, body: { error: final.error, dispatched: final.dispatched } }
+            : { status: 200, body: final };
         }
         if (reply.status === 200) {
           const opened = openResponse(prepared, reply.body, this.deployment, this.now());
@@ -256,7 +310,8 @@ export class Consumer {
           if (this.journalDir) recordRequest(this.journalDir, prepared, opened, relay.url);
           return opened;
         }
-        lastError = Object.assign(new Error(reply.body?.error || `Relay returned ${reply.status}`), { status: reply.status });
+        lastError = Object.assign(new Error(reply.body?.error || `Relay returned ${reply.status}`),
+          { status: reply.status, dispatched: reply.body?.dispatched });
         if (reply.body?.dispatched !== false || ![502, 503].includes(reply.status)) throw lastError;
       }
     }
@@ -279,20 +334,50 @@ async function readJson(req) {
   return JSON.parse(Buffer.concat(chunks).toString("utf8") || "{}");
 }
 
-/** Local OpenAI-compatible endpoint; nothing leaves this machine unsealed except pricing and routing. */
+/** Anthropic Messages and Gemini generateContent: translated to a chat request, answered in the client's dialect. */
+async function dialectRequest(req, res, active, path, setWriter) {
+  const body = await readJson(req);
+  const gemini = geminiRoute(path);
+  const ask = gemini ? fromGemini(body, gemini.model) : fromAnthropic(body);
+  const stream = gemini ? gemini.stream : ask.stream;
+  const request = { endpoint: "chat", model: ask.model, content: ask.messages, maxOutputTokens: ask.maxOutputTokens, options: ask.options };
+  if (!stream) {
+    const { response, receipt } = await active.request(request);
+    const answer = outputText(response.output);
+    const out = gemini ? toGemini(ask.model, answer, receipt.receipt) : toAnthropic(ask.model, answer, receipt.receipt);
+    res.writeHead(200, { "content-type": "application/json", "cache-control": "no-store" });
+    return res.end(JSON.stringify(out));
+  }
+  const write = (chunk) => {
+    if (!res.headersSent) res.writeHead(200, { "content-type": "text/event-stream", "cache-control": "no-store", connection: "keep-alive" });
+    res.write(chunk);
+  };
+  const writer = gemini ? geminiStream(write, ask.model) : anthropicStream(write, ask.model);
+  setWriter(writer);
+  let streamedAny = false;
+  const { response, receipt } = await active.request({ ...request, onDelta: (piece) => { streamedAny ||= Boolean(piece); writer.delta(piece); } });
+  writer.finish(outputText(response.output), receipt.receipt, streamedAny);
+  return res.end();
+}
+
+/** Local OpenAI-compatible endpoint (plus the Anthropic and Gemini dialects); nothing leaves this machine unsealed except pricing and routing. */
 export function serveConsumer(consumer, { host = "127.0.0.1", port = 8110, apiKey, dataDir, tenants = () => ({}) } = {}) {
   const routes = dataDir ? consoleRoutes({ consumer, dataDir }) : {};
-  const bearer = (req) => /^Bearer (.+)$/.exec(String(req.headers.authorization || ""))?.[1];
+  // Every dialect's way of presenting a key: OpenAI Bearer, Anthropic x-api-key, Gemini x-goog-api-key or ?key=.
+  const bearer = (req) => /^Bearer (.+)$/.exec(String(req.headers.authorization || ""))?.[1]
+    || req.headers["x-api-key"] || req.headers["x-goog-api-key"] || new URL(req.url, "http://localhost").searchParams.get("key") || undefined;
   const server = createServer(async (req, res) => {
     let writer = null;
+    let dialect = "openai";
     const send = (status, body, type = "application/json") => {
       res.writeHead(status, { "content-type": type, "cache-control": "no-store" });
       res.end(type === "application/json" ? JSON.stringify(body) : body);
     };
     try {
       const path = new URL(req.url, "http://localhost").pathname.replace(/^\/v1\/v1\//, "/v1/");
+      dialect = path === "/v1/messages" ? "anthropic" : geminiRoute(path) ? "gemini" : "openai";
       // A tenant's API key selects its own payment key and budget; tenants may call from anywhere.
-      const tenant = path.startsWith("/v1/") && bearer(req) ? tenants()[hashApiKey(bearer(req))] : undefined;
+      const tenant = /^\/v1(beta|alpha)?\//.test(path) && bearer(req) ? tenants()[hashApiKey(bearer(req))] : undefined;
       if (!tenant && !localRequestAllowed(req, server.address().port)) {
         return send(403, openaiError("only this machine may use the local node", "forbidden"));
       }
@@ -305,12 +390,16 @@ export function serveConsumer(consumer, { host = "127.0.0.1", port = 8110, apiKe
         const result = await route(req.method === "POST" ? await readJson(req) : {});
         return result?.type ? send(200, result.body, result.type) : send(200, result);
       }
-      if (!tenant && bearer(req) && bearer(req) !== apiKey) return send(401, openaiError("invalid API key", "unauthorized"));
+      // Without a configured key the local node trusts this machine (Host and Origin are checked above), so
+      // clients that insist on sending some key (Claude Code, the Gemini CLI) still work.
       if (!tenant && apiKey && bearer(req) !== apiKey) return send(401, openaiError("invalid API key", "unauthorized"));
-      if (req.method === "GET" && path === "/health") return send(200, { ok: true, protocol: 11, key: consumer.key });
       if (req.method === "GET" && path === "/v1/models") {
-        return send(200, { object: "list", data: (await active.models()).map((id) => ({ id, object: "model", owned_by: "mycomesh" })) });
+        const catalog = active.catalog?.() || {};
+        return send(200, { object: "list", data: (await active.models()).map((model) => ({
+          id: model, object: "model", owned_by: "mycomesh", ...(catalog[model] ? { mycomesh: catalog[model] } : {}) })) });
       }
+      if (req.method === "POST" && dialect !== "openai") return await dialectRequest(req, res, active, path, (w) => { writer = w; });
+      if (req.method === "GET" && path === "/health") return send(200, { ok: true, protocol: 11, key: consumer.key });
       if (req.method !== "POST" || !["/v1/responses", "/v1/chat/completions", "/responses", "/chat/completions"].includes(path)) {
         return send(404, openaiError("not found", "not_found"));
       }
@@ -345,6 +434,8 @@ export function serveConsumer(consumer, { host = "127.0.0.1", port = 8110, apiKe
         return send(error.status, { error: error.message });
       }
       const status = error.code === "outcome_unknown" ? 504 : (error.status && error.status < 500 ? error.status : 502);
+      if (dialect === "anthropic") return send(status, anthropicError(error.message, status));
+      if (dialect === "gemini") return send(status, geminiError(error.message, status));
       return send(status, openaiError(error.message, error.code || "request_failed"));
     }
   });

package/src/dialects.mjs

@@ -0,0 +1,135 @@
+// Client dialects for the local endpoint: Anthropic Messages and Gemini generateContent, translated to and
+// from the network's chat requests (OpenAI shape), streaming included. Token counts come from the
+// Provider-signed receipt, so every client sees what it was charged for.
+import { randomUUID } from "node:crypto";
+
+const id = (prefix) => `${prefix}${randomUUID().replace(/-/g, "")}`;
+
+export class DialectError extends Error {
+  constructor(message, status = 400) { super(message); this.status = status; }
+}
+
+/** Text of Anthropic or Gemini content: a string or text blocks/parts. Other block kinds are refused. */
+function text(content, where) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) throw new DialectError(`${where}: content must be text`);
+  return content.map((part) => {
+    if (typeof part === "string") return part;
+    if (part && typeof part.text === "string" && (part.type === undefined || part.type === "text")) return part.text;
+    if (part?.type === "thinking" || part?.type === "redacted_thinking" || part?.thought) return "";
+    throw new DialectError(`${where}: only text content is supported (got ${part?.type || Object.keys(part || {})[0] || "unknown"})`);
+  }).join("");
+}
+
+const unsupportedTools = (present) => {
+  if (present) throw new DialectError("tool use is not supported on this network yet; send text-only requests");
+};
+
+// ---------------- Anthropic Messages ----------------
+
+/** POST /v1/messages body -> { model, messages, maxOutputTokens, options, stream } */
+export function fromAnthropic(body) {
+  if (typeof body.model !== "string" || !Array.isArray(body.messages)) throw new DialectError("model and messages are required");
+  unsupportedTools(body.tools?.length || body.tool_choice);
+  const messages = [];
+  if (body.system !== undefined) messages.push({ role: "system", content: text(body.system, "system") });
+  for (const message of body.messages) {
+    if (!["user", "assistant"].includes(message?.role)) throw new DialectError("messages alternate user and assistant");
+    messages.push({ role: message.role, content: text(message.content, `${message.role} message`) });
+  }
+  const options = {};
+  for (const key of ["temperature", "top_p"]) if (body[key] !== undefined) options[key] = body[key];
+  if (body.stop_sequences) options.stop = body.stop_sequences;
+  return { model: body.model, messages, maxOutputTokens: body.max_tokens ?? 4096, options, stream: body.stream === true };
+}
+
+export function toAnthropic(model, answer, receipt) {
+  return {
+    id: id("msg_"), type: "message", role: "assistant", model,
+    content: [{ type: "text", text: answer }], stop_reason: "end_turn", stop_sequence: null,
+    usage: { input_tokens: Number(receipt.input_tokens), output_tokens: Number(receipt.output_tokens) },
+  };
+}
+
+/** Anthropic's SSE event sequence, fed with text as it arrives. */
+export function anthropicStream(write, model) {
+  const event = (type, data) => write(`event: ${type}\ndata: ${JSON.stringify({ type, ...data })}\n\n`);
+  let started = false;
+  const start = () => {
+    if (started) return;
+    started = true;
+    event("message_start", { message: { id: id("msg_"), type: "message", role: "assistant", model, content: [],
+      stop_reason: null, stop_sequence: null, usage: { input_tokens: 0, output_tokens: 0 } } });
+    event("content_block_start", { index: 0, content_block: { type: "text", text: "" } });
+  };
+  return {
+    delta(piece) { start(); if (piece) event("content_block_delta", { index: 0, delta: { type: "text_delta", text: piece } }); },
+    finish(answer, receipt, streamedAny) {
+      start();
+      if (!streamedAny && answer) event("content_block_delta", { index: 0, delta: { type: "text_delta", text: answer } });
+      event("content_block_stop", { index: 0 });
+      event("message_delta", { delta: { stop_reason: "end_turn", stop_sequence: null },
+        usage: { input_tokens: Number(receipt.input_tokens), output_tokens: Number(receipt.output_tokens) } });
+      event("message_stop", {});
+    },
+    fail(message) { event("error", { error: { type: "api_error", message } }); },
+  };
+}
+
+export const anthropicError = (message, status) => ({ type: "error", error: {
+  type: status === 401 || status === 403 ? "authentication_error" : status === 404 ? "not_found_error"
+    : status === 402 ? "billing_error" : status >= 500 ? "api_error" : "invalid_request_error", message } });
+
+// ---------------- Gemini generateContent ----------------
+
+const GEMINI_PATH = /^\/(?:v1|v1beta|v1alpha)\/models\/([^/:]+):(generateContent|streamGenerateContent)$/;
+
+/** The model and whether it streams, for a Gemini path; null for any other path. */
+export function geminiRoute(path) {
+  const match = GEMINI_PATH.exec(path);
+  return match ? { model: decodeURIComponent(match[1]), stream: match[2] === "streamGenerateContent" } : null;
+}
+
+export function fromGemini(body, model) {
+  if (!Array.isArray(body.contents)) throw new DialectError("contents are required");
+  unsupportedTools(body.tools?.length);
+  const messages = [];
+  const system = body.systemInstruction || body.system_instruction;
+  if (system) messages.push({ role: "system", content: text(system.parts ?? system, "systemInstruction") });
+  for (const item of body.contents) {
+    const role = item.role === "model" ? "assistant" : "user";
+    messages.push({ role, content: text(item.parts, `${item.role || "user"} content`) });
+  }
+  const config = body.generationConfig || body.generation_config || {};
+  const options = {};
+  if (config.temperature !== undefined) options.temperature = config.temperature;
+  if (config.topP !== undefined) options.top_p = config.topP;
+  if (config.stopSequences) options.stop = config.stopSequences;
+  return { model, messages, maxOutputTokens: config.maxOutputTokens ?? 4096, options };
+}
+
+function geminiChunk(model, piece, receipt) {
+  const chunk = { candidates: [{ content: { role: "model", parts: [{ text: piece }] }, index: 0 }], modelVersion: model };
+  if (receipt) {
+    chunk.candidates[0].finishReason = "STOP";
+    const input = Number(receipt.input_tokens); const output = Number(receipt.output_tokens);
+    chunk.usageMetadata = { promptTokenCount: input, candidatesTokenCount: output, totalTokenCount: input + output };
+  }
+  return chunk;
+}
+
+export const toGemini = (model, answer, receipt) => geminiChunk(model, answer, receipt);
+
+/** streamGenerateContent with alt=sse: one JSON chunk per event; the last carries finishReason and usage. */
+export function geminiStream(write, model) {
+  const chunk = (value) => write(`data: ${JSON.stringify(value)}\n\n`);
+  return {
+    delta(piece) { if (piece) chunk(geminiChunk(model, piece)); },
+    finish(answer, receipt, streamedAny) { chunk(geminiChunk(model, streamedAny ? "" : answer, receipt)); },
+    fail(message) { chunk({ error: { code: 500, message, status: "INTERNAL" } }); },
+  };
+}
+
+export const geminiError = (message, status) => ({ error: { code: status, message,
+  status: status === 400 ? "INVALID_ARGUMENT" : status === 401 || status === 403 ? "PERMISSION_DENIED"
+    : status === 404 ? "NOT_FOUND" : status === 402 ? "RESOURCE_EXHAUSTED" : "INTERNAL" } });

package/src/pricing.mjs

@@ -26,6 +26,7 @@ export async function networkPrices(network) {
     const scale = (value) => ((value * multiplier + UNIT - 1n) / UNIT).toString();
     tiers.push({
       tier: Number(tier), name: meta.name, models: meta.models, target_bps: Number(targetBps),
+      catalog: Object.fromEntries((meta.models || []).map((model) => [model, network.models?.[model] || null])),
       multiplier: Number(multiplier), multiplier_yesterday: Number(previous),
       prices: { input_per_1k: scale(baseIn), output_per_1k: scale(baseOut), minimum_fee: scale(minFee) },
       yesterday: { demand: demand.toString(), supply: supply.toString(), utilization_bps: supply ? Number((demand * 10_000n) / supply) : 0 },

package/src/web/console.html

@@ -132,6 +132,10 @@
     <p class="muted">全网统一价，像比特币难度一样每天自动调整：前一天的利用率（成交 ÷ 在线产能）高于目标就涨，低于就降，单日最多 ±10%。</p>
     <table style="margin-bottom:22px"><thead><tr><th>档位</th><th>模型</th><th>输入 / 1k</th><th>输出 / 1k</th><th>最低</th><th>价格系数</th><th>昨日利用率 / 目标</th></tr></thead>
       <tbody id="pricing"></tbody></table>
+    <h2>模型目录</h2>
+    <p class="muted">网络上有哪些模型、属于哪个档位、能做什么。价格见上表（同档位同价）。本机接口同时支持 OpenAI、Anthropic（<code>/v1/messages</code>）和 Gemini（<code>generateContent</code>）三种格式。</p>
+    <table style="margin-bottom:22px"><thead><tr><th>模型</th><th>厂商</th><th>档位</th><th>能力</th><th>说明</th><th>在线 Provider</th></tr></thead>
+      <tbody id="catalog"></tbody></table>
     <div id="network"></div>
   </section>
 </main>
@@ -370,10 +374,22 @@ async function refreshPricing() {
       <td>${fmt(t.prices.minimum_fee)}</td><td>${(t.multiplier / 1e6).toFixed(3)}× ${arrow}</td>
       <td>${(t.yesterday.utilization_bps / 100).toFixed(1)}% / ${(t.target_bps / 100).toFixed(0)}%</td></tr>`;
   }).join("") || `<tr><td colspan="7" class="muted">这个网络还没有启用网络定价。</td></tr>`;
+  const models = tiers.flatMap((t) => t.models.map((model) => ({ model, tier: t, meta: t.catalog?.[model] })));
+  const online = window.onlineModels || {};
+  const caps = (m) => !m ? "—" : [m.capabilities?.streaming ? "流式" : null, m.reasoning_efforts ? `推理强度 ${m.reasoning_efforts.join("/")}` : null,
+    m.capabilities?.tools ? "工具调用" : "暂不支持工具调用", `输入 ${(m.capabilities?.input || ["text"]).join("/")}`].filter(Boolean).join(" · ");
+  $("catalog").innerHTML = models.map(({ model, tier, meta }) => `<tr><td class="mono">${model}</td><td>${meta?.vendor || "—"}</td>
+    <td>${tier.name}</td><td>${caps(meta)}</td><td>${meta?.summary || ""}</td><td>${online[model] ?? "…"}</td></tr>`).join("")
+    || `<tr><td colspan="6" class="muted">清单里没有模型目录。</td></tr>`;
 }
 async function refreshNetwork() {
-  refreshPricing().catch(() => {});
   const { relays } = await api("/api/network");
+  // Online Providers per model, for the catalog.
+  window.onlineModels = {};
+  for (const relay of relays) for (const p of relay.providers) for (const m of p.models) {
+    window.onlineModels[m] = (window.onlineModels[m] || 0) + (relay.healthy ? 1 : 0);
+  }
+  refreshPricing().catch(() => {});
   $("relays").textContent = `Relay ${relays.filter((r) => r.healthy).length}/${relays.length}`;
   $("relays").className = relays.some((r) => r.healthy) ? "badge ok" : "badge";
   $("network").innerHTML = "";