mtok-bridge 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Roy Ashbrook
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,43 @@
+# mtok-bridge
+
+Serve any model as an OpenAI-compatible API, gated by a key. No payment, no market, no account,
+nothing reported anywhere. Runs anywhere node runs.
+
+```
+npx mtok-bridge --upstream https://api.openai.com/v1 --upstream-key sk-... --model gpt-4o-mini
+npx mtok-bridge --upstream http://localhost:11434/v1 --model llama3.2      # a local ollama server
+```
+
+It prints an endpoint and an api key. Hand them to whoever should use it:
+
+```
+curl http://localhost:8790/v1/chat/completions \
+  -H "authorization: Bearer <the-printed-key>" \
+  -H "content-type: application/json" \
+  -d '{"model":"gpt-4o-mini","messages":[{"role":"user","content":"hi"}]}'
+```
+
+## flags
+
+- `--upstream <url>` (required): any OpenAI-compatible chat/completions root (a provider, or your
+  own model server: ollama, LM Studio, vLLM, etc).
+- `--upstream-key <key>`: the upstream's bearer token, if it needs one.
+- `--model <id>`: a model you serve (repeatable, or a comma list). Omit to pass the upstream's
+  default through.
+- `--port <n>`: default 8790.
+- `--api-key <key>`: the key clients send. Omit and one is generated + printed for you.
+- `--keyless`: serve with NO key (anyone who can reach the endpoint can use it). Opt-in.
+
+## want to get paid for it?
+
+The bridge is the transport half of [mtok.market](https://mtok.market)'s seller relay. When you
+want to get PAID for a model (on-chain, per call, in USDC on Base) and be discovered on the market
+board instead of handing out keys, the market relay wraps this exact bridge with settlement. Same
+tool, one layer on top.
+
+
+---
+
+Read-only public mirror. The source of truth is the private mtok.market
+monorepo; this repo is synced automatically. Do not open pull requests here.
+Home: https://mtok.market

package/mtok-bridge.mjs

@@ -0,0 +1,75 @@
+#!/usr/bin/env node
+// mtok-bridge CLI: serve a model as an OpenAI-compatible API, keyed, no payment, no market.
+// Runs anywhere node runs. Point it at any OpenAI-compatible upstream (a provider, or your own
+// local model server), hand out the endpoint + key. When you want to get PAID + discovered for
+// the same model, the market relay (npx mtok-relay) wraps this exact core with on-chain settlement.
+//
+//   npx mtok-bridge --upstream https://api.openai.com/v1 --upstream-key sk-... --model gpt-4o-mini
+//   npx mtok-bridge --upstream http://localhost:11434/v1 --model llama3.2   # a local ollama server
+//
+// Flags: --upstream <url> (required), --upstream-key <key>, --model <id> (repeatable or comma-list),
+//        --port <n> (default 8790), --api-key <key> (default: generate + print one), --keyless.
+import http from 'node:http';
+import crypto from 'node:crypto';
+import { serveChat, httpUpstream } from './src/bridge.mjs';
+
+function parseArgs(argv) {
+  const o = { models: [], port: 8790 };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === '--keyless') { o.keyless = true; continue; }
+    if (!a.startsWith('--')) { console.error(`ABORT: unexpected argument "${a}"`); process.exit(1); }
+    const name = a.slice(2);
+    const val = argv[++i];
+    if (name === 'model') o.models.push(...String(val || '').split(',').map((s) => s.trim()).filter(Boolean));
+    else if (name === 'upstream') o.upstream = val;
+    else if (name === 'upstream-key') o.upstreamKey = val;
+    else if (name === 'port') o.port = Number(val) || 8790;
+    else if (name === 'api-key') o.apiKey = val;
+    else { console.error(`ABORT: unknown flag --${name}`); process.exit(1); }
+  }
+  return o;
+}
+
+const o = parseArgs(process.argv.slice(2));
+if (!o.upstream) { console.error('need --upstream <openai-compatible url> (e.g. https://api.openai.com/v1 or http://localhost:11434/v1)'); process.exit(1); }
+const apiKey = o.keyless ? null : (o.apiKey || 'mtok_' + crypto.randomBytes(24).toString('hex'));
+const upstream = httpUpstream({ baseUrl: o.upstream, key: o.upstreamKey });
+
+const readBody = (req) => new Promise((resolve) => {
+  let data = ''; let over = false;
+  req.on('data', (c) => { data += c; if (data.length > 2_000_000) { over = true; req.destroy(); } });
+  req.on('end', () => resolve(over ? null : data));
+  req.on('error', () => resolve(null));
+});
+const send = (res, status, json) => { res.writeHead(status, { 'content-type': 'application/json' }); res.end(JSON.stringify(json)); };
+
+const server = http.createServer(async (req, res) => {
+  const path = (req.url || '').split('?')[0];
+  if (req.method === 'GET' && path === '/v1/models') {
+    return send(res, 200, { object: 'list', data: (o.models.length ? o.models : ['(upstream default)']).map((id) => ({ id, object: 'model' })) });
+  }
+  if (req.method === 'POST' && path === '/v1/chat/completions') {
+    const raw = await readBody(req);
+    if (raw === null) return send(res, 413, { error: { message: 'body too large or unreadable', type: 'invalid_request_error' } });
+    let body; try { body = JSON.parse(raw || '{}'); } catch { return send(res, 400, { error: { message: 'invalid JSON', type: 'invalid_request_error' } }); }
+    const r = await serveChat({ body, authHeader: req.headers['authorization'], apiKey, models: o.models, upstream });
+    return send(res, r.status, r.json);
+  }
+  return send(res, 404, { error: { message: 'not found; POST /v1/chat/completions', type: 'invalid_request_error' } });
+});
+
+server.listen(o.port, () => {
+  const base = `http://localhost:${o.port}/v1`;
+  console.log('mtok-bridge is serving.');
+  console.log(`  endpoint:  ${base}`);
+  console.log(`  models:    ${o.models.length ? o.models.join(', ') : '(whatever the upstream serves)'}`);
+  console.log(apiKey ? `  api key:   ${apiKey}` : '  api key:   NONE (--keyless: anyone who can reach this endpoint can use it)');
+  console.log('\n  hand these to whoever should use it. example:');
+  console.log(`    curl ${base}/chat/completions \\`);
+  if (apiKey) console.log(`      -H "authorization: Bearer ${apiKey}" \\`);
+  console.log(`      -H "content-type: application/json" \\`);
+  console.log(`      -d '{"model":"${o.models[0] ?? 'MODEL'}","messages":[{"role":"user","content":"hi"}]}'`);
+  console.log('\n  want to get PAID for this model instead of handing out keys? the market relay');
+  console.log('  (npx mtok-relay) wraps this same bridge with on-chain settlement. see mtok.market.');
+});

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "mtok-bridge",
+  "version": "0.1.0",
+  "description": "Serve any model as an OpenAI-compatible API with a key. No payment, no market, runs anywhere node runs. The transport core behind mtok.market's seller relay.",
+  "type": "module",
+  "bin": {
+    "mtok-bridge": "mtok-bridge.mjs"
+  },
+  "exports": {
+    ".": "./src/bridge.mjs"
+  },
+  "files": [
+    "mtok-bridge.mjs",
+    "src",
+    "README.md"
+  ],
+  "scripts": {
+    "test": "node --test"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "keywords": [
+    "llm",
+    "openai-compatible",
+    "proxy",
+    "bridge",
+    "mtok"
+  ],
+  "license": "MIT",
+  "homepage": "https://mtok.market",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mtok-market/bridge.git"
+  }
+}

package/src/bridge.mjs

@@ -0,0 +1,71 @@
+// mtok-bridge core: the TRANSPORT guts of a model seller, with NO payment and NO market.
+// Serve any model as an OpenAI-compatible API, gated by an api key. Runtime-agnostic and
+// dependency-free: the request logic is pure functions; a host (the node CLI here, a CF Worker
+// later, the market relay on top) adapts its req/res to them. The market layer (on-chain verify,
+// fee, redemption, discovery) is a SEPARATE wrapper that calls the same serveChat guts; it is not
+// in here. (#566)
+
+// Bearer-key auth. No key configured (null/'') = OPEN on purpose (keyless mode is an explicit
+// opt-in the CLI announces loudly). A configured key must match exactly.
+export function checkAuth(authHeader, apiKey) {
+  if (!apiKey) return true;
+  const m = /^Bearer\s+(.+)$/i.exec(String(authHeader || ''));
+  return !!m && m[1] === apiKey;
+}
+
+// Resolve the requested model against the served set. Empty set = pass the request through
+// (the upstream decides). One-or-more served models: default to the first when none is asked,
+// and reject a model we do not serve (null = not allowed).
+export function pickModel(requested, models) {
+  const set = Array.isArray(models) ? models.filter(Boolean) : [];
+  if (!set.length) return requested || null;
+  if (!requested) return set[0];
+  return set.includes(requested) ? requested : null;
+}
+
+// Core chat handler. `upstream(payload)` returns an OpenAI-shaped completion (or throws). Returns
+// { status, json } for the host to serialize. This is the whole free bridge; the market layer
+// wraps it with a verify step in front.
+export async function serveChat({ body, authHeader, apiKey, models, upstream }) {
+  if (!checkAuth(authHeader, apiKey)) {
+    return { status: 401, json: { error: { message: 'missing or invalid api key', type: 'auth_error' } } };
+  }
+  if (!body || !Array.isArray(body.messages) || !body.messages.length) {
+    return { status: 400, json: { error: { message: 'messages[] is required', type: 'invalid_request_error' } } };
+  }
+  const model = pickModel(body.model, models);
+  if (!model) {
+    const served = (Array.isArray(models) ? models : []).join(', ') || '(any)';
+    return { status: 400, json: { error: { message: `model "${body.model}" is not served here (served: ${served})`, type: 'invalid_request_error' } } };
+  }
+  let completion;
+  try {
+    completion = await upstream({ ...body, model });
+  } catch (e) {
+    return { status: 502, json: { error: { message: `upstream error: ${e?.message ?? e}`, type: 'upstream_error' } } };
+  }
+  return { status: 200, json: completion };
+}
+
+// Build an upstream function that forwards to any OpenAI-compatible chat/completions endpoint.
+// `baseUrl` is the API root (e.g. https://api.openai.com/v1 or a local model server); `key` is
+// its bearer token (optional for a keyless local server). This is what makes the bridge portable:
+// point it at a provider, or at ollama / LM Studio / vLLM on localhost.
+export function httpUpstream({ baseUrl, key }) {
+  const url = String(baseUrl || '').replace(/\/$/, '') + '/chat/completions';
+  return async (payload) => {
+    const res = await fetch(url, {
+      method: 'POST',
+      headers: {
+        'content-type': 'application/json',
+        ...(key ? { authorization: `Bearer ${key}` } : {}),
+      },
+      body: JSON.stringify(payload),
+    });
+    const text = await res.text();
+    let json;
+    try { json = JSON.parse(text); } catch { throw new Error(`non-JSON upstream response (${res.status})`); }
+    if (!res.ok) throw new Error(json?.error?.message || `upstream ${res.status}`);
+    return json;
+  };
+}