mycomesh-consumer 0.9.3 → 0.9.4

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.4",
   "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

@@ -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;
@@ -198,6 +200,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()) {
@@ -279,20 +286,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 +342,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 +386,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 = "";