@nanogpt/private-mode 0.1.0

package/README.md

@@ -0,0 +1,85 @@
+# NanoGPT Private Mode
+
+OpenAI-compatible localhost proxy for NanoGPT Private Mode with Tinfoil-backed models.
+
+```bash
+NANOGPT_API_KEY=sk-your-key npx @nanogpt/private-mode
+```
+
+Then point any OpenAI-compatible client at:
+
+```text
+http://127.0.0.1:8787/v1
+```
+
+Example:
+
+```ts
+import OpenAI from "openai";
+
+const client = new OpenAI({
+  baseURL: "http://127.0.0.1:8787/v1",
+  apiKey: "unused",
+});
+
+const response = await client.chat.completions.create({
+  model: "private/kimi-k2-6",
+  messages: [{ role: "user", content: "Hello" }],
+});
+```
+
+The local proxy verifies Tinfoil attestation, encrypts request bodies with EHBP, sends ciphertext through NanoGPT, decrypts encrypted responses locally, and returns normal OpenAI JSON to the calling app.
+
+NanoGPT can see account identity, selected private model, selected Tinfoil enclave metadata, timing, sizes, status, and usage metadata. NanoGPT cannot read the prompt or completion body for supported private models.
+
+NanoGPT's web app can also use these models without running this local proxy. Select an eligible Tinfoil-backed `TEE/*` model and use the Private Mode control in the model picker. This package is for API clients, CLIs, agents, and other OpenAI-compatible tools.
+
+The web-app toggle is narrower than the proxy path in v1. It supports text chat and model settings, and disables attachments, web search, URL-scraped content, project tools, multi-model chat, Context Memory injection, quick replies, and automatic title generation for private turns.
+
+In the hosted web app, decrypted Private Mode turns remain in local browser history. Cloud conversation sync is blocked for Private Mode chats unless password-based end-to-end sync is enabled; the recoverable default sync mode is not used for those chats.
+
+Private Mode also requires enough NanoGPT balance and API-key spend-limit headroom before dispatch. NanoGPT cannot read encrypted prompts to count tokens, so the reserve uses the encrypted request size when available and otherwise falls back to a conservative model estimate capped at 32,768 output tokens by default (`NANOGPT_PRIVATE_TINFOIL_RESERVE_MAX_OUTPUT_TOKENS`). The final charge is still based on Tinfoil usage metrics.
+
+Useful local checks:
+
+```text
+GET http://127.0.0.1:8787/v1/models
+GET http://127.0.0.1:8787/v1/private-mode/status
+GET http://127.0.0.1:8787/v1/private-mode/attestation
+```
+
+Browser requests are locked down by default. The proxy only accepts same-machine clients and rejects browser `Origin` headers that are not explicitly allowed, so a random website or LAN client cannot spend the local `NANOGPT_API_KEY` while the proxy is running. If a local browser app needs to call the proxy directly, allow that exact origin:
+
+```bash
+NANOGPT_API_KEY=sk-your-key npx @nanogpt/private-mode --allow-origin http://localhost:3000
+```
+
+You can also set `NANOGPT_PRIVATE_ALLOWED_ORIGINS=http://localhost:3000`. Wildcard browser origins are not supported.
+
+The hosted web app streams Private Mode chat by default. The local proxy preserves OpenAI API semantics: omitted `stream` returns a single JSON response, and `stream: true` returns server-sent events. For streaming calls, NanoGPT precharges a reserve before dispatch so interrupted streams remain billable, then refunds unused reserve when verified usage metadata is available at the end of the stream.
+
+## Verification receipts
+
+NanoGPT's hosted web app shows a Private Mode receipt on completed Private Mode responses. The receipt includes:
+
+- browser attestation result
+- TEE target and enclave host
+- verifier step statuses
+- expected and runtime measurement fingerprints
+- attestation bundle SHA-256 when available
+- verification document SHA-256
+- request/response encryption flags
+
+To independently verify a copied receipt:
+
+```bash
+npx @nanogpt/private-mode verify receipt.json
+```
+
+You can also pipe JSON on stdin:
+
+```bash
+cat receipt.json | npx @nanogpt/private-mode verify
+```
+
+The verifier re-fetches attestation material for the receipt's enclave, verifies it locally, and checks the resulting measurements, release digest, and HPKE key against the copied receipt. If an optional attestation bundle hash is present but the freshly fetched bundle serializes differently, the verifier prints a warning instead of failing the core verification.

package/bin/nanogpt-private-mode.js

@@ -0,0 +1,73 @@
+#!/usr/bin/env node
+
+import { parseArgs } from 'node:util';
+import { startPrivateModeProxy } from '../lib/server.js';
+import { verifyPrivateModeReceiptCli } from '../lib/verifyReceipt.js';
+
+const { values, positionals } = parseArgs({
+  options: {
+    host: { type: 'string', default: process.env.HOST || '127.0.0.1' },
+    port: { type: 'string', short: 'p', default: process.env.PORT || '8787' },
+    'api-base': {
+      type: 'string',
+      default: process.env.NANOGPT_API_BASE || 'https://nano-gpt.com',
+    },
+    'allow-origin': { type: 'string', multiple: true },
+    help: { type: 'boolean', short: 'h', default: false },
+  },
+  allowPositionals: true,
+});
+
+if (values.help) {
+  process.stdout.write(`NanoGPT Private Mode Proxy
+
+Usage:
+  NANOGPT_API_KEY=sk-... nanogpt-private-mode
+  nanogpt-private-mode verify receipt.json
+  cat receipt.json | nanogpt-private-mode verify
+
+Options:
+  --host <host>       Local bind host. Default: 127.0.0.1
+  --port, -p <port>   Local port. Default: 8787
+  --api-base <url>    NanoGPT API base. Default: https://nano-gpt.com
+  --allow-origin <origin>
+                     Browser origin allowed to call the proxy, for example http://localhost:3000
+`);
+  process.exit(0);
+}
+
+if (positionals[0] === 'verify') {
+  try {
+    const exitCode = await verifyPrivateModeReceiptCli(positionals.slice(1));
+    process.exit(exitCode);
+  } catch (error) {
+    process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+    process.exit(1);
+  }
+} else if (positionals.length > 0) {
+  process.stderr.write(`Unknown command: ${positionals[0]}\n`);
+  process.exit(1);
+}
+
+const port = Number.parseInt(String(values.port), 10);
+if (!Number.isFinite(port) || port <= 0 || port > 65535) {
+  process.stderr.write('Invalid --port value.\n');
+  process.exit(1);
+}
+
+const apiKey = process.env.NANOGPT_API_KEY?.trim();
+if (!apiKey) {
+  process.stderr.write('Set NANOGPT_API_KEY before starting the proxy.\n');
+  process.exit(1);
+}
+
+startPrivateModeProxy({
+  apiBase: String(values['api-base']),
+  apiKey,
+  host: String(values.host),
+  port,
+  allowedOrigins: values['allow-origin'],
+}).catch((error) => {
+  process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+  process.exit(1);
+});

package/lib/originPolicy.js

@@ -0,0 +1,115 @@
+const DEFAULT_LOCAL_HOSTS = ['127.0.0.1', 'localhost', '[::1]'];
+
+export function normalizePrivateModeOrigin(value) {
+  const origin = String(value || '').trim();
+  if (!origin || origin === 'null' || origin === '*') return null;
+  try {
+    const parsed = new URL(origin);
+    if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') return null;
+    return parsed.origin;
+  } catch {
+    return null;
+  }
+}
+
+function splitOriginValues(values) {
+  if (!values) return [];
+  const list = Array.isArray(values) ? values : [values];
+  return list
+    .flatMap((value) => String(value || '').split(','))
+    .map((value) => value.trim())
+    .filter(Boolean);
+}
+
+function normalizeHostForOrigin(host) {
+  const trimmed = String(host || '').trim();
+  if (!trimmed || trimmed === '0.0.0.0' || trimmed === '::' || trimmed === '[::]') return null;
+  if (trimmed.includes(':') && !trimmed.startsWith('[')) return `[${trimmed}]`;
+  return trimmed;
+}
+
+export function buildPrivateModeOriginPolicy(options = {}) {
+  const port = Number.parseInt(String(options.port || '8787'), 10);
+  const allowedOrigins = new Set();
+
+  if (Number.isFinite(port) && port > 0) {
+    for (const host of DEFAULT_LOCAL_HOSTS) {
+      allowedOrigins.add(`http://${host}:${port}`);
+    }
+
+    const normalizedHost = normalizeHostForOrigin(options.host);
+    if (normalizedHost) {
+      const origin = normalizePrivateModeOrigin(`http://${normalizedHost}:${port}`);
+      if (origin) allowedOrigins.add(origin);
+    }
+  }
+
+  const configuredOrigins = [
+    ...splitOriginValues(process.env.NANOGPT_PRIVATE_ALLOWED_ORIGINS),
+    ...splitOriginValues(options.allowedOrigins),
+  ];
+
+  for (const configuredOrigin of configuredOrigins) {
+    const origin = normalizePrivateModeOrigin(configuredOrigin);
+    if (!origin) {
+      throw new Error(`Invalid Private Mode browser origin "${configuredOrigin}". Use an http(s) origin, not a wildcard.`);
+    }
+    allowedOrigins.add(origin);
+  }
+
+  return {
+    allowedOrigins: [...allowedOrigins],
+  };
+}
+
+export function isPrivateModeOriginAllowed(originPolicy, origin) {
+  if (!origin) return false;
+  return getAllowedPrivateModeOrigin(originPolicy, origin) !== null;
+}
+
+function getAllowedPrivateModeOrigin(originPolicy, origin) {
+  const normalizedOrigin = normalizePrivateModeOrigin(origin);
+  if (!normalizedOrigin || !originPolicy.allowedOrigins.includes(normalizedOrigin)) return null;
+  return normalizedOrigin;
+}
+
+export function isLoopbackRemoteAddress(remoteAddress) {
+  const normalized = String(remoteAddress || '').trim().toLowerCase();
+  if (!normalized) return false;
+  if (normalized === '::1' || normalized === '0:0:0:0:0:0:0:1') return true;
+
+  const ipv4 = normalized.startsWith('::ffff:')
+    ? normalized.slice('::ffff:'.length)
+    : normalized;
+  const parts = ipv4.split('.');
+  if (parts.length !== 4) return false;
+  const octets = parts.map((part) => Number(part));
+  if (!octets.every((octet, index) => (
+    Number.isInteger(octet) &&
+    octet >= 0 &&
+    octet <= 255 &&
+    String(octet) === parts[index]
+  ))) {
+    return false;
+  }
+
+  return octets[0] === 127;
+}
+
+export function getCorsHeadersForOrigin(originPolicy, origin) {
+  if (!origin) return {};
+
+  const normalizedOrigin = getAllowedPrivateModeOrigin(originPolicy, origin);
+  if (!normalizedOrigin) return null;
+
+  return {
+    'access-control-allow-origin': normalizedOrigin,
+    vary: 'Origin',
+  };
+}
+
+export function getCorsHeadersForRequest(req, originPolicy) {
+  if (!isLoopbackRemoteAddress(req.socket?.remoteAddress)) return null;
+  const origin = typeof req.headers.origin === 'string' ? req.headers.origin : '';
+  return getCorsHeadersForOrigin(originPolicy, origin);
+}

package/lib/requestTransforms.js

@@ -0,0 +1,227 @@
+const MODELS_REQUIRING_TOOL_CHOICE_REQUIRED = new Set([
+  'phala/qwen-2.5-7b-instruct',
+]);
+const ASSISTANT_REASONING_MESSAGE_FIELDS = [
+  'reasoning',
+  'reasoning_content',
+  'reasoning_details',
+];
+
+// Keep request mutation behavior in sync with lib/privateMode/tinfoilBrowserClient.ts
+// for explicit fields. The local proxy preserves OpenAI's non-streaming default.
+function isPlainObject(value) {
+  return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+
+function isThinkingEnabled(thinking) {
+  if (typeof thinking === 'boolean') return thinking;
+  if (!isPlainObject(thinking)) return undefined;
+
+  const type = typeof thinking.type === 'string'
+    ? thinking.type.toLowerCase()
+    : undefined;
+  if (type === 'enabled') return true;
+  if (type === 'disabled') return false;
+
+  if (typeof thinking.enabled === 'boolean') {
+    return thinking.enabled;
+  }
+
+  return undefined;
+}
+
+function isReasoningEnabled(reasoning) {
+  if (typeof reasoning === 'boolean') return reasoning;
+  if (!isPlainObject(reasoning)) return undefined;
+
+  if (reasoning.exclude === true || reasoning.enabled === false) return false;
+  if (reasoning.enabled === true) return true;
+  if (typeof reasoning.effort === 'string') {
+    return reasoning.effort.toLowerCase() !== 'none';
+  }
+
+  return undefined;
+}
+
+function normalizeDeepSeekV4ReasoningEffort(value) {
+  const normalized = typeof value === 'string' ? value.trim().toLowerCase() : '';
+  if (normalized === 'max' || normalized === 'xhigh') return 'max';
+  if (normalized === 'medium') return 'medium';
+  if (normalized === 'low' || normalized === 'minimal') return 'low';
+  return 'high';
+}
+
+function getPrivateModeModelSignals(body, model) {
+  return [
+    body.model,
+    model.id,
+    model.billingModel,
+    ...(model.aliases || []),
+  ].map((value) => String(value || '').toLowerCase());
+}
+
+function shouldEnableThinking(body, model) {
+  const explicitThinking = isThinkingEnabled(body.thinking);
+  const explicitReasoning = isReasoningEnabled(body.reasoning);
+  const reasoningEffort = String(body.reasoning_effort || '').toLowerCase();
+  const modelSignals = getPrivateModeModelSignals(body, model);
+  const hasThinkingSuffix = modelSignals.some((value) => (
+    value.includes(':thinking') || value.endsWith('-thinking')
+  ));
+
+  return explicitThinking
+    ?? explicitReasoning
+    ?? (body.reasoning_effort !== undefined ? reasoningEffort !== 'none' : undefined)
+    ?? hasThinkingSuffix;
+}
+
+function mergeChatTemplateKwargs(body) {
+  return isPlainObject(body.chat_template_kwargs) ? body.chat_template_kwargs : {};
+}
+
+function stripPrivateModeReasoningBlocks(value) {
+  return value
+    .replace(/◁think▷/g, '<think>')
+    .replace(/◁\/think▷/g, '</think>')
+    .replace(/<think>[\s\S]*?<\/think>\s*/gi, '')
+    .replace(/<previous_reasoning>[\s\S]*?<\/previous_reasoning>\s*/gi, '')
+    .trimStart();
+}
+
+function stripPrivateModeReasoningFromContent(value) {
+  if (typeof value === 'string') return stripPrivateModeReasoningBlocks(value);
+  if (!Array.isArray(value)) return value;
+
+  return value.map((part) => {
+    if (!isPlainObject(part)) return part;
+    if (part.type === 'text' && typeof part.text === 'string') {
+      return {
+        ...part,
+        text: stripPrivateModeReasoningBlocks(part.text),
+      };
+    }
+    return part;
+  });
+}
+
+function stripPrivateModeReasoningFromMessages(body) {
+  if (!Array.isArray(body.messages)) return;
+
+  body.messages = body.messages.map((message) => {
+    if (!isPlainObject(message) || message.role !== 'assistant') return message;
+
+    const sanitized = { ...message };
+    for (const field of ASSISTANT_REASONING_MESSAGE_FIELDS) {
+      delete sanitized[field];
+    }
+    if ('content' in sanitized) {
+      sanitized.content = stripPrivateModeReasoningFromContent(sanitized.content);
+    }
+    if ('prompt' in sanitized) {
+      sanitized.prompt = stripPrivateModeReasoningFromContent(sanitized.prompt);
+    }
+    return sanitized;
+  });
+}
+
+function buildJsonSchemaPromptSuffix(responseFormat) {
+  if (!isPlainObject(responseFormat?.json_schema)) return null;
+  const schemaWrapper = responseFormat.json_schema;
+  const schemaName = schemaWrapper.name || 'response';
+  const schema = schemaWrapper.schema || schemaWrapper;
+  return [
+    '',
+    '',
+    '<json_output_instructions>',
+    'CRITICAL: Respond with ONLY valid JSON. Do not use markdown code fences.',
+    `Required JSON Schema ("${schemaName}"):\n${JSON.stringify(schema, null, 2)}`,
+    '</json_output_instructions>',
+  ].join('\n');
+}
+
+function appendSystemInstruction(body, instruction) {
+  if (typeof instruction !== 'string' || !instruction.trim()) return;
+  const messages = Array.isArray(body.messages) ? body.messages : [];
+  const firstMessage = messages[0];
+  if (
+    isPlainObject(firstMessage) &&
+    firstMessage.role === 'system' &&
+    typeof firstMessage.content === 'string'
+  ) {
+    firstMessage.content = `${firstMessage.content}${instruction}`;
+    body.messages = messages;
+    return;
+  }
+
+  body.messages = [
+    { role: 'system', content: instruction.trim() },
+    ...messages,
+  ];
+}
+
+function applyTinfoilCompatibilityMutations(body, model) {
+  if (body.response_format?.type === 'json_schema') {
+    appendSystemInstruction(body, buildJsonSchemaPromptSuffix(body.response_format));
+    body.response_format = { type: 'json_object' };
+  }
+
+  if (
+    Array.isArray(body.tools) &&
+    body.tools.length > 0 &&
+    MODELS_REQUIRING_TOOL_CHOICE_REQUIRED.has(model.upstreamModel) &&
+    (!body.tool_choice || body.tool_choice === 'auto')
+  ) {
+    body.tool_choice = 'required';
+  }
+}
+
+export function applyPrivateModelRequestMutations(body, model) {
+  stripPrivateModeReasoningFromMessages(body);
+
+  if (body.max_tokens === undefined && body.maxTokens !== undefined) {
+    body.max_tokens = body.maxTokens;
+  }
+  delete body.maxTokens;
+
+  body.model = model.upstreamModel;
+  if (body.stream !== undefined) {
+    body.stream = body.stream === true;
+  }
+  if (body.stream === true) {
+    body.stream_options = {
+      ...(body.stream_options && typeof body.stream_options === 'object' ? body.stream_options : {}),
+      include_usage: true,
+    };
+  }
+  applyTinfoilCompatibilityMutations(body, model);
+
+  if (model.thinkingMode === 'gemma') {
+    body.chat_template_kwargs = {
+      ...mergeChatTemplateKwargs(body),
+      enable_thinking: shouldEnableThinking(body, model),
+    };
+    delete body.thinking;
+    delete body.reasoning_effort;
+    return body;
+  }
+
+  if (model.thinkingMode === 'deepseek-v4-pro') {
+    const thinkingEnabled = shouldEnableThinking(body, model);
+    body.chat_template_kwargs = {
+      ...mergeChatTemplateKwargs(body),
+      thinking: thinkingEnabled,
+    };
+
+    if (thinkingEnabled) {
+      body.chat_template_kwargs.reasoning_effort =
+        normalizeDeepSeekV4ReasoningEffort(body.reasoning_effort);
+    } else {
+      delete body.chat_template_kwargs.reasoning_effort;
+    }
+
+    delete body.thinking;
+    delete body.reasoning_effort;
+  }
+
+  return body;
+}

package/lib/server.js

@@ -0,0 +1,503 @@
+import { createServer } from 'node:http';
+import { readFileSync } from 'node:fs';
+
+import {
+  buildPrivateModeOriginPolicy,
+  getCorsHeadersForRequest,
+} from './originPolicy.js';
+import { applyPrivateModelRequestMutations } from './requestTransforms.js';
+import { buildPrivateModeStatusContract } from './statusContract.js';
+
+const MODELS = JSON.parse(
+  readFileSync(new URL('../models/tinfoil.json', import.meta.url), 'utf8'),
+);
+
+function readMaxBodyBytes() {
+  const parsed = Number(process.env.NANOGPT_PRIVATE_MAX_BODY_BYTES || '');
+  if (Number.isFinite(parsed) && parsed > 0) return Math.floor(parsed);
+  return 25 * 1024 * 1024;
+}
+
+const MAX_BODY_BYTES = readMaxBodyBytes();
+
+function normalizeApiBase(apiBase) {
+  const parsed = new URL(apiBase);
+  if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') {
+    throw new Error('NANOGPT_API_BASE must be an http(s) URL.');
+  }
+  return parsed.toString().replace(/\/+$/, '');
+}
+
+function normalizeModelId(value) {
+  return String(value || '').trim().toLowerCase();
+}
+
+const MODEL_BY_ID = new Map();
+for (const model of MODELS) {
+  const candidates = [
+    model.id,
+    model.id.replace(/^private\//, ''),
+    model.upstreamModel,
+    model.billingModel,
+    ...(model.aliases || []),
+  ];
+  for (const candidate of candidates) {
+    const normalized = normalizeModelId(candidate);
+    if (normalized && !MODEL_BY_ID.has(normalized)) MODEL_BY_ID.set(normalized, model);
+  }
+}
+
+export function resolveModel(modelId) {
+  return MODEL_BY_ID.get(normalizeModelId(modelId)) || null;
+}
+
+function openAIModelList() {
+  return {
+    object: 'list',
+    data: MODELS.map((model) => ({
+      id: model.id,
+      object: 'model',
+      created: model.created,
+      owned_by: model.ownedBy,
+    })),
+  };
+}
+
+export function privateModeStatus(apiBase, secureState, localBase, originPolicy) {
+  return {
+    ok: true,
+    mode: 'tinfoil',
+    apiBase,
+    local_base_url: localBase,
+    models_path: '/v1/models',
+    status_path: '/v1/private-mode/status',
+    attestation_path: '/v1/private-mode/attestation',
+    chat_completions_path: '/v1/chat/completions',
+    max_body_bytes: MAX_BODY_BYTES,
+    transport: 'ehbp',
+    request_body_encrypted: true,
+    response_body_encrypted: true,
+    streaming: true,
+    streaming_billing: 'precharged_reserve_with_verified_usage_refund',
+    api_local_proxy_required: true,
+    browser_frontend_local_proxy_required: false,
+    ...buildPrivateModeStatusContract(),
+    browser_origins_allowed: originPolicy.allowedOrigins,
+    models: openAIModelList().data,
+    attestation: secureState.getVerificationState(),
+  };
+}
+
+function jsonResponse(res, status, body, headers = {}) {
+  const payload = Buffer.from(JSON.stringify(body));
+  res.writeHead(status, {
+    'content-type': 'application/json',
+    'content-length': String(payload.length),
+    ...headers,
+  });
+  res.end(payload);
+}
+
+function textResponse(res, status, body, headers = {}) {
+  const payload = Buffer.from(body);
+  res.writeHead(status, {
+    'content-type': 'text/plain; charset=utf-8',
+    'content-length': String(payload.length),
+    ...headers,
+  });
+  res.end(payload);
+}
+
+function notFound(res, corsHeaders) {
+  jsonResponse(res, 404, {
+    error: {
+      message: 'Not found',
+      type: 'invalid_request_error',
+      code: 'not_found',
+    },
+  }, corsHeaders);
+}
+
+function readBody(req) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    let size = 0;
+    req.on('data', (chunk) => {
+      if (size > MAX_BODY_BYTES) return;
+      size += chunk.length;
+      if (size > MAX_BODY_BYTES) {
+        reject(new Error('Request body is too large.'));
+        return;
+      }
+      chunks.push(chunk);
+    });
+    req.on('end', () => resolve(Buffer.concat(chunks)));
+    req.on('error', reject);
+  });
+}
+
+function copyLocalHeaders(req) {
+  const headers = {};
+  const teamId = req.headers['x-team-id'];
+  if (typeof teamId === 'string' && teamId.trim()) {
+    headers['x-team-id'] = teamId.trim();
+  }
+  return headers;
+}
+
+function createSecureState(apiBase) {
+  let clientPromise = null;
+  let verificationDocument = null;
+  let verificationError = null;
+
+  async function getClient() {
+    if (!clientPromise) {
+      clientPromise = import('tinfoil')
+        .then(async ({ SecureClient }) => {
+          const baseURL = `${apiBase}/api/v1/private/tinfoil/`;
+          const client = new SecureClient({
+            baseURL,
+            attestationBundleURL: `${apiBase}/api/v1/private/tinfoil`,
+            transport: 'ehbp',
+          });
+          await client.ready();
+          verificationDocument = client.getVerificationDocument();
+          verificationError = null;
+          return client;
+        })
+        .catch((error) => {
+          clientPromise = null;
+          verificationError = error;
+          throw error;
+        });
+    }
+    return clientPromise;
+  }
+
+  return {
+    getClient,
+    getVerificationState() {
+      return {
+        verified: verificationDocument?.securityVerified === true,
+        verificationDocument,
+        error: verificationError ? String(verificationError.message || verificationError) : null,
+      };
+    },
+  };
+}
+
+async function runPreflight({ apiBase, apiKey, model, req, requestBodyBytes }) {
+  const preflightBody = { model: model.id };
+  if (Number.isSafeInteger(requestBodyBytes) && requestBodyBytes >= 0) {
+    preflightBody.requestBodyBytes = requestBodyBytes;
+  }
+
+  const response = await fetch(`${apiBase}/api/v1/private/tinfoil/preflight`, {
+    method: 'POST',
+    headers: {
+      authorization: `Bearer ${apiKey}`,
+      'content-type': 'application/json',
+      ...copyLocalHeaders(req),
+    },
+    body: JSON.stringify(preflightBody),
+  });
+
+  if (response.ok) return { ok: true };
+
+  let errorBody = null;
+  try {
+    errorBody = await response.json();
+  } catch {
+    errorBody = {
+      error: {
+        message: `NanoGPT preflight failed with HTTP ${response.status}`,
+        type: 'invalid_request_error',
+        code: 'preflight_failed',
+      },
+    };
+  }
+  return { ok: false, status: response.status, body: errorBody };
+}
+
+async function handleChatCompletion({ apiBase, apiKey, secureState, req, res, corsHeaders }) {
+  let rawBody;
+  try {
+    rawBody = await readBody(req);
+  } catch (error) {
+    jsonResponse(res, 413, {
+      error: {
+        message: error instanceof Error ? error.message : String(error),
+        type: 'invalid_request_error',
+        code: 'body_too_large',
+      },
+    }, corsHeaders);
+    return;
+  }
+
+  let body;
+  try {
+    body = JSON.parse(rawBody.toString('utf8'));
+  } catch {
+    jsonResponse(res, 400, {
+      error: {
+        message: 'Request body must be JSON.',
+        type: 'invalid_request_error',
+        code: 'invalid_json',
+      },
+    }, corsHeaders);
+    return;
+  }
+
+  const model = resolveModel(body.model);
+  if (!model) {
+    jsonResponse(res, 400, {
+      error: {
+        message: `Unsupported private model "${body.model || ''}".`,
+        type: 'invalid_request_error',
+        code: 'model_not_supported',
+      },
+    }, corsHeaders);
+    return;
+  }
+
+  applyPrivateModelRequestMutations(body, model);
+  const privateStreamRequested = body.stream === true;
+
+  const privateRequestBody = JSON.stringify(body);
+  const preflight = await runPreflight({
+    apiBase,
+    apiKey,
+    model,
+    req,
+    requestBodyBytes: Buffer.byteLength(privateRequestBody, 'utf8'),
+  });
+  if (!preflight.ok) {
+    jsonResponse(res, preflight.status, preflight.body, corsHeaders);
+    return;
+  }
+
+  let response;
+  const upstreamAbortController = new AbortController();
+  let responseComplete = false;
+  res.on('close', () => {
+    if (!responseComplete) upstreamAbortController.abort();
+  });
+
+  try {
+    const client = await secureState.getClient();
+    response = await client.fetch(`${apiBase}/api/v1/private/tinfoil/v1/chat/completions`, {
+      method: 'POST',
+      headers: {
+        authorization: `Bearer ${apiKey}`,
+        'content-type': 'application/json',
+        accept: privateStreamRequested ? 'text/event-stream' : 'application/json',
+        'x-nanogpt-private-model': model.id,
+        'x-nanogpt-private-stream': privateStreamRequested ? 'true' : 'false',
+        'x-query-source': 'api',
+        ...copyLocalHeaders(req),
+      },
+      body: privateRequestBody,
+      signal: upstreamAbortController.signal,
+    });
+  } catch (error) {
+    responseComplete = true;
+    if (res.destroyed) return;
+    jsonResponse(res, 502, {
+      error: {
+        message: `Private Mode request failed: ${error instanceof Error ? error.message : String(error)}`,
+        type: 'api_error',
+        code: 'private_mode_request_failed',
+      },
+    }, corsHeaders);
+    return;
+  }
+
+  const headers = {
+    ...corsHeaders,
+    'content-type': response.headers.get('content-type') || 'application/json',
+  };
+  const requestId = response.headers.get('x-request-id');
+  if (requestId) headers['x-request-id'] = requestId;
+  const privateMode = response.headers.get('x-nanogpt-private-mode');
+  if (privateMode) headers['x-nanogpt-private-mode'] = privateMode;
+
+  if (privateStreamRequested && response.body) {
+    res.writeHead(response.status, headers);
+    const reader = response.body.getReader();
+    let streamFailed = false;
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        if (res.destroyed) {
+          await reader.cancel('client disconnected');
+          upstreamAbortController.abort();
+          return;
+        }
+        if (value) res.write(Buffer.from(value));
+      }
+    } catch (error) {
+      streamFailed = true;
+      upstreamAbortController.abort();
+      if (!res.destroyed) {
+        res.destroy(error instanceof Error ? error : new Error(String(error)));
+      }
+      return;
+    } finally {
+      responseComplete = true;
+      if (!streamFailed && !res.writableEnded && !res.destroyed) res.end();
+    }
+    return;
+  }
+
+  const responseBody = Buffer.from(await response.arrayBuffer());
+  headers['content-length'] = String(responseBody.length);
+  responseComplete = true;
+  res.writeHead(response.status, headers);
+  res.end(responseBody);
+}
+
+function resolveAccessControlAllowHeaders(req) {
+  const requestedHeaders = req.headers['access-control-request-headers'];
+  if (typeof requestedHeaders === 'string' && requestedHeaders.trim()) {
+    return requestedHeaders
+      .split(',')
+      .map((header) => header.trim().toLowerCase())
+      .filter(Boolean)
+      .join(', ');
+  }
+
+  return 'authorization, content-type, x-team-id';
+}
+
+function handleOptions(req, res, corsHeaders) {
+  res.writeHead(204, {
+    ...corsHeaders,
+    'access-control-allow-methods': 'GET,POST,OPTIONS',
+    'access-control-allow-headers': resolveAccessControlAllowHeaders(req),
+    'access-control-max-age': '86400',
+  });
+  res.end();
+}
+
+export async function startPrivateModeProxy(options) {
+  const apiBase = normalizeApiBase(options.apiBase);
+  const secureState = createSecureState(apiBase);
+  const localBase = `http://${options.host}:${options.port}/v1`;
+  const originPolicy = buildPrivateModeOriginPolicy(options);
+
+  const server = createServer(async (req, res) => {
+    try {
+      const url = new URL(req.url || '/', `http://${req.headers.host || '127.0.0.1'}`);
+      const corsHeaders = getCorsHeadersForRequest(req, originPolicy);
+      if (corsHeaders === null) {
+        jsonResponse(res, 403, {
+          error: {
+            message: 'Request origin is not allowed to use this Private Mode proxy.',
+            type: 'invalid_request_error',
+            code: 'origin_not_allowed',
+          },
+        });
+        return;
+      }
+
+      if (req.method === 'OPTIONS') {
+        handleOptions(req, res, corsHeaders);
+        return;
+      }
+
+      if (req.method === 'GET' && url.pathname === '/health') {
+        jsonResponse(res, 200, privateModeStatus(apiBase, secureState, localBase, originPolicy), corsHeaders);
+        return;
+      }
+
+      if (req.method === 'GET' && url.pathname === '/v1/models') {
+        jsonResponse(res, 200, openAIModelList(), corsHeaders);
+        return;
+      }
+
+      if (req.method === 'GET' && url.pathname === '/v1/private-mode/status') {
+        jsonResponse(res, 200, privateModeStatus(apiBase, secureState, localBase, originPolicy), corsHeaders);
+        return;
+      }
+
+      if (req.method === 'GET' && url.pathname === '/v1/private-mode/attestation') {
+        try {
+          await secureState.getClient();
+          jsonResponse(res, 200, secureState.getVerificationState(), corsHeaders);
+        } catch (error) {
+          jsonResponse(res, 502, {
+            verified: false,
+            verificationDocument: null,
+            error: error instanceof Error ? error.message : String(error),
+          }, corsHeaders);
+        }
+        return;
+      }
+
+      if (req.method === 'POST' && url.pathname === '/v1/chat/completions') {
+        await handleChatCompletion({
+          apiBase,
+          apiKey: options.apiKey,
+          secureState,
+          req,
+          res,
+          corsHeaders,
+        });
+        return;
+      }
+
+      if (req.method === 'GET' && url.pathname === '/') {
+        textResponse(res, 200, `NanoGPT Private Mode Proxy\nOpenAI base URL: ${localBase}\nStatus: /v1/private-mode/status\n`, corsHeaders);
+        return;
+      }
+
+      notFound(res, corsHeaders);
+    } catch (error) {
+      if (res.destroyed) return;
+      if (res.headersSent) {
+        res.destroy(error instanceof Error ? error : new Error(String(error)));
+        return;
+      }
+      jsonResponse(res, 500, {
+        error: {
+          message: error instanceof Error ? error.message : String(error),
+          type: 'api_error',
+          code: 'internal_error',
+        },
+      });
+    }
+  });
+
+  await new Promise((resolve, reject) => {
+    server.once('error', reject);
+    server.listen(options.port, options.host, resolve);
+  });
+
+  if (options.quiet !== true) {
+    process.stdout.write(`NanoGPT Private Mode Proxy
+Local base URL: ${localBase}
+NanoGPT API: ${apiBase}
+Models: ${MODELS.map((model) => model.id).join(', ')}
+Status: http://${options.host}:${options.port}/v1/private-mode/status
+Allowed browser origins: ${originPolicy.allowedOrigins.join(', ')}
+
+Request and response bodies are encrypted after they leave this local proxy.
+NanoGPT can see your account, private model header, timing, sizes, status, and usage metadata.
+The verified Tinfoil enclave and this local proxy can see plaintext.
+`);
+  }
+
+  if (options.warmAttestation !== false) {
+    secureState.getClient()
+      .then((client) => {
+        const doc = client.getVerificationDocument();
+        process.stdout.write(`Attestation: verified=${doc.securityVerified === true}; enclave=${doc.enclaveHost || client.getEnclaveURL() || 'unknown'}\n`);
+      })
+      .catch((error) => {
+        process.stderr.write(`Attestation failed: ${error instanceof Error ? error.message : String(error)}\n`);
+      });
+  }
+
+  return server;
+}

package/lib/statusContract.js

@@ -0,0 +1,54 @@
+export const PRIVATE_MODE_FRONTEND_SUPPORTED_FEATURES = Object.freeze([
+  'text_chat',
+  'streaming',
+  'conversation_history',
+  'model_settings',
+  'reasoning_modes',
+]);
+
+export const PRIVATE_MODE_FRONTEND_DISABLED_FEATURES = Object.freeze([
+  'attachments',
+  'web_search',
+  'url_scraped_content',
+  'project_chats',
+  'project_tools',
+  'multi_model',
+  'context_memory',
+  'recoverable_cloud_sync',
+  'quick_replies',
+  'auto_title_generation',
+]);
+
+export const PRIVATE_MODE_NANOGPT_VISIBLE = Object.freeze([
+  'account',
+  'selected_private_model',
+  'selected_tinfoil_enclave',
+  'request_timing',
+  'request_size',
+  'response_size',
+  'status',
+  'usage_metadata',
+]);
+
+export const PRIVATE_MODE_ENCRYPTED_FROM_NANOGPT = Object.freeze([
+  'messages',
+  'system_prompt',
+  'tools',
+  'attachments',
+  'model_response',
+]);
+
+export const PRIVATE_MODE_PLAINTEXT_VISIBLE_TO = Object.freeze([
+  'local_proxy',
+  'verified_tinfoil_enclave',
+]);
+
+export function buildPrivateModeStatusContract() {
+  return {
+    frontend_supported_features: [...PRIVATE_MODE_FRONTEND_SUPPORTED_FEATURES],
+    frontend_disabled_features: [...PRIVATE_MODE_FRONTEND_DISABLED_FEATURES],
+    nanogpt_visible: [...PRIVATE_MODE_NANOGPT_VISIBLE],
+    encrypted_from_nanogpt: [...PRIVATE_MODE_ENCRYPTED_FROM_NANOGPT],
+    plaintext_visible_to: [...PRIVATE_MODE_PLAINTEXT_VISIBLE_TO],
+  };
+}

package/lib/verifyReceipt.js

@@ -0,0 +1,170 @@
+import { createHash } from 'node:crypto';
+import { readFile } from 'node:fs/promises';
+import { fetchAttestationBundle, Verifier } from 'tinfoil';
+
+function isRecord(value) {
+  return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+
+function stableStringify(value) {
+  if (Array.isArray(value)) {
+    return `[${value.map((item) => stableStringify(item)).join(',')}]`;
+  }
+  if (isRecord(value)) {
+    return `{${Object.keys(value)
+      .sort()
+      .map((key) => `${JSON.stringify(key)}:${stableStringify(value[key])}`)
+      .join(',')}}`;
+  }
+  return JSON.stringify(value);
+}
+
+function sha256Json(value) {
+  return createHash('sha256').update(stableStringify(value)).digest('hex');
+}
+
+async function readStdin() {
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(Buffer.from(chunk));
+  }
+  return Buffer.concat(chunks).toString('utf8');
+}
+
+async function readReceiptInput(path) {
+  if (path) return readFile(path, 'utf8');
+  return readStdin();
+}
+
+function normalizeEnclaveUrl(receipt) {
+  const raw = receipt?.verifier?.selectedRouterEndpoint
+    || receipt?.verifier?.enclaveHost
+    || receipt?.response?.enclave;
+  if (typeof raw !== 'string' || !raw.trim()) {
+    throw new Error('Receipt does not include an enclave host or router endpoint.');
+  }
+
+  const trimmed = raw.trim();
+  return /^https:\/\//i.test(trimmed) ? trimmed : `https://${trimmed}`;
+}
+
+function isNonEmptyString(value) {
+  return typeof value === 'string' && value.trim().length > 0;
+}
+
+function assertRequiredEqual(failures, label, actual, expected) {
+  if (!isNonEmptyString(expected)) {
+    failures.push(`${label} missing from receipt.`);
+    return;
+  }
+  if (!isNonEmptyString(actual)) {
+    failures.push(`${label} missing from fresh verifier result.`);
+    return;
+  }
+  if (actual !== expected) {
+    failures.push(`${label} mismatch: expected ${expected}, got ${actual || 'missing'}`);
+  }
+}
+
+function assertOptionalEqual(warnings, label, actual, expected) {
+  if (!isNonEmptyString(expected)) return;
+  if (!isNonEmptyString(actual)) {
+    warnings.push(`${label} missing from fresh verifier result.`);
+    return;
+  }
+  if (actual !== expected) {
+    warnings.push(`${label} mismatch: expected ${expected}, got ${actual || 'missing'}`);
+  }
+}
+
+function assertReceiptFlag(failures, label, value) {
+  if (value !== true) {
+    failures.push(`${label} was not true in receipt.`);
+  }
+}
+
+export async function verifyPrivateModeReceipt(receipt) {
+  if (!isRecord(receipt) || receipt.schemaVersion !== 1) {
+    throw new Error('Unsupported or invalid Private Mode receipt.');
+  }
+
+  const configRepo = receipt.verifier?.configRepo;
+  if (typeof configRepo !== 'string' || !configRepo.trim()) {
+    throw new Error('Receipt does not include a verifier policy repo.');
+  }
+
+  const enclaveURL = normalizeEnclaveUrl(receipt);
+  const bundle = await fetchAttestationBundle({
+    enclaveURL,
+    configRepo,
+  });
+  const attestationBundleSha256 = sha256Json(bundle);
+
+  const verifier = new Verifier({ configRepo });
+  await verifier.verifyBundle(bundle);
+  const doc = verifier.getVerificationDocument();
+  const verificationDocumentSha256 = sha256Json(doc);
+
+  const failures = [];
+  const warnings = [];
+  if (doc?.securityVerified !== true) {
+    failures.push('Fresh verifier result is not securityVerified=true.');
+  }
+  if (receipt.status !== 'verified') {
+    failures.push(`Receipt status is ${receipt.status || 'missing'}; expected verified.`);
+  }
+
+  const encryption = isRecord(receipt.encryption) ? receipt.encryption : {};
+  if (encryption.transport !== 'EHBP') {
+    failures.push(`Receipt transport is ${encryption.transport || 'missing'}; expected EHBP.`);
+  }
+  assertReceiptFlag(failures, 'Request body encrypted', encryption.requestBodyEncrypted);
+  assertReceiptFlag(failures, 'Response body encrypted', encryption.responseBodyEncrypted);
+  assertReceiptFlag(failures, 'NanoGPT proxy confirmation', encryption.nanoGptProxyConfirmed);
+
+  assertRequiredEqual(failures, 'Expected measurement', doc?.codeFingerprint, receipt.verifier?.codeFingerprint);
+  assertRequiredEqual(failures, 'Runtime measurement', doc?.enclaveFingerprint, receipt.verifier?.enclaveFingerprint);
+  assertRequiredEqual(failures, 'Release digest', doc?.releaseDigest, receipt.verifier?.releaseDigest);
+  assertRequiredEqual(failures, 'HPKE public key', doc?.hpkePublicKey, receipt.verifier?.hpkePublicKey);
+  assertOptionalEqual(warnings, 'Attestation bundle SHA-256', attestationBundleSha256, receipt.verifier?.attestationBundleSha256);
+
+  return {
+    ok: failures.length === 0,
+    failures,
+    warnings,
+    enclaveURL,
+    codeFingerprint: doc?.codeFingerprint,
+    enclaveFingerprint: doc?.enclaveFingerprint,
+    attestationBundleSha256,
+    verificationDocumentSha256,
+  };
+}
+
+export async function verifyPrivateModeReceiptCli(positionals, io = process) {
+  const receiptPath = positionals[0];
+  const input = await readReceiptInput(receiptPath);
+  const receipt = JSON.parse(input);
+  const result = await verifyPrivateModeReceipt(receipt);
+
+  if (!result.ok) {
+    io.stderr.write('Private Mode receipt verification failed.\n');
+    for (const failure of result.failures) {
+      io.stderr.write(`- ${failure}\n`);
+    }
+    return 2;
+  }
+
+  io.stdout.write('Private Mode receipt verified.\n');
+  io.stdout.write(`Enclave: ${result.enclaveURL}\n`);
+  io.stdout.write(`Expected measurement: ${result.codeFingerprint}\n`);
+  io.stdout.write(`Runtime measurement: ${result.enclaveFingerprint}\n`);
+  io.stdout.write(`Attestation bundle SHA-256: ${result.attestationBundleSha256}\n`);
+  io.stdout.write(`Verification document SHA-256: ${result.verificationDocumentSha256}\n`);
+  if (result.warnings.length > 0) {
+    io.stderr.write('Private Mode receipt verification warnings:\n');
+    for (const warning of result.warnings) {
+      io.stderr.write(`- ${warning}\n`);
+    }
+  }
+  return 0;
+}

package/models/tinfoil.json

@@ -0,0 +1,96 @@
+[
+  {
+    "id": "private/kimi-k2-6",
+    "name": "Kimi K2.6 Private",
+    "upstreamModel": "kimi-k2-6",
+    "billingModel": "TEE/kimi-k2-6",
+    "tinfoilEnclaveModel": "kimi-k2-6",
+    "created": 1764547200,
+    "ownedBy": "nanogpt-tinfoil",
+    "aliases": ["private/kimi-k2.6", "TEE/kimi-k2-6", "TEE/kimi-k2.6"]
+  },
+  {
+    "id": "private/gpt-oss-120b",
+    "name": "GPT OSS 120B Private",
+    "upstreamModel": "gpt-oss-120b",
+    "billingModel": "TEE/gpt-oss-120b",
+    "tinfoilEnclaveModel": "gpt-oss-120b",
+    "created": 1764547200,
+    "ownedBy": "nanogpt-tinfoil",
+    "aliases": ["TEE/gpt-oss-120b", "phala/gpt-oss-120b"]
+  },
+  {
+    "id": "private/llama3-3-70b",
+    "name": "Llama 3.3 70B Private",
+    "upstreamModel": "llama3-3-70b",
+    "billingModel": "TEE/llama3-3-70b",
+    "tinfoilEnclaveModel": "llama3-3-70b",
+    "created": 1764547200,
+    "ownedBy": "nanogpt-tinfoil",
+    "aliases": ["private/llama-3.3-70b", "TEE/llama3-3-70b"]
+  },
+  {
+    "id": "private/glm-5-1",
+    "name": "GLM 5.1 Private",
+    "upstreamModel": "glm-5-1",
+    "billingModel": "TEE/glm-5-1",
+    "tinfoilEnclaveModel": "glm-5-1",
+    "created": 1764547200,
+    "ownedBy": "nanogpt-tinfoil",
+    "aliases": ["private/glm-5.1", "TEE/glm-5-1", "TEE/glm-5.1"]
+  },
+  {
+    "id": "private/glm-5-1-thinking",
+    "name": "GLM 5.1 Thinking Private",
+    "upstreamModel": "glm-5-1",
+    "billingModel": "TEE/glm-5-1-thinking",
+    "tinfoilEnclaveModel": "glm-5-1",
+    "created": 1764547200,
+    "ownedBy": "nanogpt-tinfoil",
+    "aliases": ["private/glm-5.1-thinking", "TEE/glm-5-1-thinking", "TEE/glm-5.1-thinking"]
+  },
+  {
+    "id": "private/gemma4-31b",
+    "name": "Gemma 4 31B Private",
+    "upstreamModel": "gemma4-31b",
+    "billingModel": "TEE/gemma4-31b",
+    "tinfoilEnclaveModel": "gemma4-31b",
+    "thinkingMode": "gemma",
+    "created": 1764547200,
+    "ownedBy": "nanogpt-tinfoil",
+    "aliases": ["TEE/gemma4-31b", "gemma4-31b"]
+  },
+  {
+    "id": "private/gemma4-31b:thinking",
+    "name": "Gemma 4 31B Thinking Private",
+    "upstreamModel": "gemma4-31b",
+    "billingModel": "TEE/gemma4-31b:thinking",
+    "tinfoilEnclaveModel": "gemma4-31b",
+    "thinkingMode": "gemma",
+    "created": 1764547200,
+    "ownedBy": "nanogpt-tinfoil",
+    "aliases": ["TEE/gemma4-31b:thinking", "gemma4-31b:thinking"]
+  },
+  {
+    "id": "private/deepseek-v4-pro",
+    "name": "DeepSeek V4 Pro Private",
+    "upstreamModel": "deepseek-v4-pro",
+    "billingModel": "TEE/deepseek-v4-pro",
+    "tinfoilEnclaveModel": "deepseek-v4-pro",
+    "thinkingMode": "deepseek-v4-pro",
+    "created": 1764547200,
+    "ownedBy": "nanogpt-tinfoil",
+    "aliases": ["TEE/deepseek-v4-pro", "deepseek-v4-pro"]
+  },
+  {
+    "id": "private/deepseek-v4-pro:thinking",
+    "name": "DeepSeek V4 Pro Thinking Private",
+    "upstreamModel": "deepseek-v4-pro",
+    "billingModel": "TEE/deepseek-v4-pro:thinking",
+    "tinfoilEnclaveModel": "deepseek-v4-pro",
+    "thinkingMode": "deepseek-v4-pro",
+    "created": 1764547200,
+    "ownedBy": "nanogpt-tinfoil",
+    "aliases": ["TEE/deepseek-v4-pro:thinking", "deepseek-v4-pro:thinking"]
+  }
+]

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@nanogpt/private-mode",
+  "version": "0.1.0",
+  "description": "OpenAI-compatible localhost proxy for NanoGPT Private Mode.",
+  "type": "module",
+  "publishConfig": {
+    "access": "public"
+  },
+  "bin": {
+    "nanogpt-private-mode": "bin/nanogpt-private-mode.js"
+  },
+  "files": [
+    "bin",
+    "lib/originPolicy.js",
+    "lib/requestTransforms.js",
+    "lib/server.js",
+    "lib/statusContract.js",
+    "lib/verifyReceipt.js",
+    "models",
+    "README.md"
+  ],
+  "scripts": {
+    "start": "node ./bin/nanogpt-private-mode.js"
+  },
+  "dependencies": {
+    "tinfoil": "1.1.3"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "license": "MIT"
+}