POST https://askmany.com/api/engine/sseQuery
Content-Type: application/json

{
  "session_group_id": "66179e48-e8d7-4525-8786-c01fb01e67c2",
  "engine": "deepseek-flash",
  "query": "hi",
  "ask_again": 0,
  "new_session": 1,
  "recover_session": 0,
  "files": [],
  "file_ids": [],
  "images": [],
  "attached_chats": [],
  "enhance": 0,
  "image_size": "1:1",
  "perfect_prompt": 1,
  "web_search": false,
  "thinking_effort": "",
  "role": "user",
  "woTitle": "hi",
  "question_id": "336075d5-b8b5-4683-a4e6-8ddad42260b7",
  "turn": 0,
  "position": 0,
  "query_id": "2c8f5f4b-30dd-4349-8dda-65c7671365d7",
  "conv_id": "b8331808-3756-4940-bd79-f9588e22c25a",
  "retry": 0,
  "group_id": "1602c1c5-473b-4ba7-8a88-caf01270f623",
  "session_id": "ab6bd70c-147e-43a3-b19b-768e0c1cf246"
}

Cookie: Authorization="Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9..."; ama_uid=<uuid>
X-Client: web
X-Client-Version: 2.0.0
Origin: https://askmany.com
Referer: https://askmany.com/

data: {"event": "thinking", "content": "> 思考中..."}   ← 思考过程
data: {"event": "thinking", "content": "The"}
data: {"event": "resp", "content": "Hi"}               ← 实际回复
data: {"event": "resp", "content": "!"}
data: {"event": "all_done"}                            ← 结束标志

OpenAI 客户端              askmany-proxy（本地）                 askmany 上游
─────────────              ─────────────────────                ─────────────
POST /v1/chat/completions ► 协议翻译层 ─────────────────────► POST /api/engine/sseQuery
（标准 OpenAI 格式）         · messages → query 折叠          （私有格式 + JWT Cookie）
                           · model → engine
                           · 生成 UUIDv4 会话字段
                           · Bearer 头 → Cookie 鉴权
                           · 伪造浏览器指纹头
                          ◄── SSE 事件翻译 ──────────────────  ◄── text/event-stream
标准 OpenAI chunk 流            · thinking → reasoning_content      thinking / resp / all_done
（reasoning_content/content）   · resp → content
                               · all_done → finish_reason + [DONE]

#!/usr/bin/env node
/**
 * askmany-proxy — 本地 OpenAI 兼容反代理（零依赖，Node >= 18）
 * 配置优先级：环境变量（大写同名）> config.json > 内置默认值
 */
'use strict';

const http = require('http');
const crypto = require('crypto');
const fs = require('fs');
const path = require('path');

/* ---------------- 配置 ---------------- */
const fileConfig = (() => {
  try { return JSON.parse(fs.readFileSync(path.join(__dirname, 'config.json'), 'utf8')); }
  catch { return {}; }
})();
const cfg = (key, def) => process.env[key.toUpperCase()] ?? fileConfig[key] ?? def;

const PORT            = Number(cfg('port', 3000));
const HOST            = String(cfg('host', '127.0.0.1'));
const UPSTREAM        = String(cfg('upstream', 'https://askmany.com')).replace(/\/+$/, '');
const ASKMANY_TOKEN   = String(cfg('askmany_token', ''));
const AMA_UID         = String(cfg('ama_uid', '')) || crypto.randomUUID();
const PROXY_API_KEY   = String(cfg('proxy_api_key', ''));
const DEFAULT_MODEL   = String(cfg('default_model', 'deepseek-flash'));
const MODELS          = String(cfg('models', 'deepseek-flash,doubao-lite,gpt-6-luna')).split(',').map(s => s.trim()).filter(Boolean);
const ALIASES         = (fileConfig.aliases && typeof fileConfig.aliases === 'object') ? fileConfig.aliases : {};
const THINKING_MODE   = String(cfg('thinking_mode', 'reasoning_content')); // reasoning_content | inline | drop
const DEBUG           = cfg('debug', '') === '1' || cfg('debug', '') === true;
const IDLE_TIMEOUT_MS = Number(cfg('idle_timeout_ms', 120000));

const UA = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36';

/* ---------------- 工具 ---------------- */
const uuid = () => crypto.randomUUID();
const nowSec = () => Math.floor(Date.now() / 1000);
const approxTokens = (s) => Math.ceil(s.length / 4);

const textOf = (content) => {
  if (typeof content === 'string') return content;
  if (Array.isArray(content)) {
    return content.map((p) => (p && typeof p === 'object' && typeof p.text === 'string') ? p.text : '').join('');
  }
  return '';
};

function sendJSON(res, status, obj) {
  if (res.writableEnded || res.destroyed) return;
  res.writeHead(status, { 'Content-Type': 'application/json; charset=utf-8' });
  res.end(JSON.stringify(obj));
}

function sendError(res, status, message, type = 'api_error') {
  sendJSON(res, status, { error: { message, type, param: null, code: status } });
}

const log = (...a) => console.log(new Date().toISOString(), ...a);
const debug = (...a) => { if (DEBUG) log('[debug]', ...a); };

/* ---------------- 上游请求 ---------------- */
function upstreamHeaders(token) {
  const headers = {
    'Content-Type': 'application/json',
    'X-Client': 'web',
    'X-Client-Version': '2.0.0',
    'Origin': UPSTREAM,
    'Referer': UPSTREAM + '/',
    'User-Agent': UA,
    'Accept': 'text/event-stream, application/json',
  };
  // 抓包确认：JWT 放在名为 Authorization 的 Cookie 中，值带 Bearer 前缀
  if (token) headers['Cookie'] = `Authorization="Bearer ${token}"; ama_uid=${AMA_UID}`;
  return headers;
}

/**
 * OpenAI messages -> 单条 query。
 * 上游多轮上下文由服务端按 session_group_id 维护，
 * 这里每次都 new_session=1 新建会话，把历史折叠进 prompt，代理完全无状态。
 */
function flattenMessages(messages) {
  const sys = messages
    .filter((m) => m.role === 'system' || m.role === 'developer')
    .map((m) => textOf(m.content)).join('\n').trim();
  const turns = messages.filter((m) => m.role === 'user' || m.role === 'assistant');
  const parts = [];
  if (sys) parts.push(`[System]\n${sys}`);
  for (const m of turns) parts.push(`[${m.role === 'user' ? 'User' : 'Assistant'}]\n${textOf(m.content)}`);
  return parts.join('\n\n');
}

function buildPayload(engine, query, { reasoningEffort, woTitle }) {
  // 所有 id 均为客户端生成的 UUIDv4（与抓包一致）
  return {
    session_group_id: uuid(),
    engine,
    query,
    ask_again: 0,
    new_session: 1,
    recover_session: 0,
    files: [],
    file_ids: [],
    images: [],
    attached_chats: [],
    enhance: 0,
    image_size: '1:1',
    perfect_prompt: 1,
    web_search: false,
    banana_image_size: '1K',
    gpt_image_size: '1024x1024',
    thinking_effort: reasoningEffort || '',
    role: 'user',
    woTitle,
    file_lengths: [],
    picked: false,
    question_id: uuid(),
    turn: 0,
    position: 0,
    query_id: uuid(),
    conv_id: uuid(),
    retry: 0,
    group_id: uuid(),
    session_id: uuid(),
  };
}

/* ---------------- /v1/chat/completions ---------------- */
function openAIChunk(id, model, delta, finishReason = null) {
  return {
    id,
    object: 'chat.completion.chunk',
    created: nowSec(),
    model,
    choices: [{ index: 0, delta, finish_reason: finishReason }],
  };
}

function clientBearer(req) {
  const h = req.headers.authorization || '';
  return h.startsWith('Bearer ') ? h.slice(7).trim() : '';
}

async function handleChatCompletions(req, res, body) {
  const requestedModel = body.model || DEFAULT_MODEL;
  const engine = ALIASES[requestedModel] || requestedModel;
  const stream = !!body.stream;
  const messages = Array.isArray(body.messages) ? body.messages : [];
  if (!messages.length) return sendError(res, 400, 'messages 不能为空', 'invalid_request_error');

  const token = ASKMANY_TOKEN || clientBearer(req);
  if (!token) {
    return sendError(res, 401,
      '未配置上游凭据：请在 config.json 设置 askmany_token，或在请求中携带可透传的 Bearer Token',
      'authentication_error');
  }

  const query = flattenMessages(messages);
  const lastUser = [...messages].reverse().find((m) => m.role === 'user');
  const payload = buildPayload(engine, query, {
    reasoningEffort: body.reasoning_effort,
    woTitle: textOf(lastUser && lastUser.content).slice(0, 30) || 'conversation',
  });

  const abort = new AbortController();
  res.on('close', () => { if (!res.writableEnded) abort.abort(); });

  log(`-> ${requestedModel}${engine !== requestedModel ? ` (via ${engine})` : ''} stream=${stream} query=${query.length}chars`);
  let upstream;
  try {
    upstream = await fetch(`${UPSTREAM}/api/engine/sseQuery`, {
      method: 'POST',
      headers: upstreamHeaders(token),
      body: JSON.stringify(payload),
      signal: abort.signal,
    });
  } catch (e) {
    return sendError(res, 502, `上游连接失败: ${e.message}`);
  }

  const ctype = upstream.headers.get('content-type') || '';
  if (!upstream.ok || !ctype.includes('text/event-stream')) {
    const text = await upstream.text().catch(() => '');
    debug('上游异常响应', upstream.status, text.slice(0, 300));
    return sendError(res, upstream.status === 401 ? 401 : 502,
      `上游返回 ${upstream.status}: ${text.slice(0, 300)}`);
  }

  const chatId = `chatcmpl-${uuid()}`;
  let content = '';
  let reasoning = '';
  let inThink = false; // inline 模式下标记 <think> 是否已开

  if (stream) {
    res.writeHead(200, {
      'Content-Type': 'text/event-stream; charset=utf-8',
      'Cache-Control': 'no-cache, no-transform',
      'Connection': 'keep-alive',
      'X-Accel-Buffering': 'no',
    });
    res.write(`data: ${JSON.stringify(openAIChunk(chatId, requestedModel, { role: 'assistant', content: null }))}\n\n`);
  }

  const emit = (delta) => res.write(`data: ${JSON.stringify(openAIChunk(chatId, requestedModel, delta))}\n\n`);
  const emitThinking = (chunk) => {
    if (THINKING_MODE === 'drop') return;
    if (THINKING_MODE === 'inline') {
      if (!inThink) { inThink = true; emit({ content: '<think>' }); }
      return emit({ content: chunk });
    }
    emit({ content: null, reasoning_content: chunk });
  };
  const emitAnswer = (chunk) => {
    if (inThink) { inThink = false; emit({ content: '</think>\n' }); }
    emit({ content: chunk, ...(THINKING_MODE === 'reasoning_content' ? { reasoning_content: null } : {}) });
  };

  // 上游 SSE 逐行解析 + OpenAI chunk 输出
  const reader = upstream.body.getReader();
  const decoder = new TextDecoder();
  let buf = '';
  let idleTimer = setTimeout(() => abort.abort(), IDLE_TIMEOUT_MS);

  const usage = () => ({
    prompt_tokens: approxTokens(query),
    completion_tokens: approxTokens(content),
    total_tokens: approxTokens(query) + approxTokens(content),
  });

  const finish = () => {
    clearTimeout(idleTimer);
    if (res.writableEnded || res.destroyed) return;
    if (stream) {
      res.write(`data: ${JSON.stringify(openAIChunk(chatId, requestedModel, {}, 'stop'))}\n\n`);
      if (body.stream_options && body.stream_options.include_usage) {
        res.write(`data: ${JSON.stringify({
          id: chatId, object: 'chat.completion.chunk', created: nowSec(), model: requestedModel,
          choices: [], usage: usage(),
        })}\n\n`);
      }
      res.write('data: [DONE]\n\n');
      res.end();
    } else {
      const message = { role: 'assistant', content };
      if (reasoning && THINKING_MODE === 'reasoning_content') message.reasoning_content = reasoning;
      sendJSON(res, 200, {
        id: chatId, object: 'chat.completion', created: nowSec(), model: requestedModel,
        choices: [{ index: 0, message, finish_reason: 'stop' }],
        usage: usage(),
      });
    }
    log(`<- done content=${content.length}chars reasoning=${reasoning.length}chars`);
  };

  try {
    for (;;) {
      const { done, value } = await reader.read();
      if (done) break;
      clearTimeout(idleTimer);
      idleTimer = setTimeout(() => abort.abort(), IDLE_TIMEOUT_MS);
      buf += decoder.decode(value, { stream: true });
      let nl;
      while ((nl = buf.indexOf('\n')) >= 0) {
        const line = buf.slice(0, nl).replace(/\r$/, '');
        buf = buf.slice(nl + 1);
        if (!line.startsWith('data:')) continue;
        const dataStr = line.slice(5).trim();
        if (!dataStr || dataStr === '[DONE]') continue;
        let evt;
        try { evt = JSON.parse(dataStr); } catch { debug('非 JSON data:', dataStr.slice(0, 200)); continue; }
        switch (evt.event) {
          case 'thinking':
            reasoning += evt.content || '';
            if (stream) emitThinking(evt.content || '');
            break;
          case 'resp':
            content += evt.content || '';
            if (stream) emitAnswer(evt.content || '');
            break;
          case 'all_done':
            break;
          case 'error':
            log('上游错误事件:', dataStr.slice(0, 300));
            if (stream) emit({ content: `\n[上游错误: ${evt.message || dataStr.slice(0, 200)}]` });
            else content += `\n[上游错误: ${evt.message || dataStr.slice(0, 200)}]`;
            break;
          default:
            debug('忽略事件:', evt.event);
        }
      }
    }
  } catch (e) {
    clearTimeout(idleTimer);
    if (res.writableEnded || res.destroyed) return;
    if (abort.signal.aborted) { // 客户端主动断开或空闲超时
      log('连接中止:', e.message);
      try { res.end(); } catch {}
      return;
    }
    const note = `\n[askmany-proxy: 上游流中断 ${e.message}]`;
    if (stream) {
      if (content || reasoning) emit({ content: note });
      else return sendError(res, 502, `上游流中断: ${e.message}`);
    } else if (!content) {
      return sendError(res, 502, `上游流中断: ${e.message}`);
    } else {
      content += note;
    }
  }
  finish();
}

/* ---------------- 其他路由 ---------------- */
function handleModels(res) {
  const all = [...new Set([...MODELS, DEFAULT_MODEL, ...Object.keys(ALIASES)])];
  sendJSON(res, 200, {
    object: 'list',
    data: all.map((id) => ({ id, object: 'model', created: 0, owned_by: 'askmany-proxy' })),
  });
}

/* ---------------- HTTP 服务 ---------------- */
const server = http.createServer((req, res) => {
  res.setHeader('Access-Control-Allow-Origin', '*');
  res.setHeader('Access-Control-Allow-Headers', 'Authorization, Content-Type, X-Api-Key');
  res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
  if (req.method === 'OPTIONS') { res.writeHead(204); return res.end(); }

  const pathname = new URL(req.url, 'http://localhost').pathname.replace(/\/+$/, '');
  const route = pathname.replace(/^\/v1/, '') || '/'; // /v1/xxx 与 /xxx 等价

  if (route === '/health') return sendJSON(res, 200, { ok: true, upstream: UPSTREAM, models: MODELS });

  if (PROXY_API_KEY) {
    const auth = req.headers.authorization || '';
    if (auth !== `Bearer ${PROXY_API_KEY}`) {
      return sendError(res, 401, '无效的 API Key', 'authentication_error');
    }
  }

  if (req.method === 'GET' && route === '/models') return handleModels(res);

  if (req.method === 'POST' && route === '/chat/completions') {
    let raw = '';
    let oversized = false;
    req.on('data', (c) => {
      raw += c;
      if (raw.length > 20 * 1024 * 1024) { oversized = true; req.destroy(); }
    });
    req.on('end', () => {
      if (oversized) return;
      let body;
      try { body = raw ? JSON.parse(raw) : {}; }
      catch { return sendError(res, 400, '请求体不是合法 JSON', 'invalid_request_error'); }
      handleChatCompletions(req, res, body)
        .catch((e) => sendError(res, 500, `代理内部错误: ${e.message}`));
    });
    return;
  }

  sendError(res, 404, `未知路由: ${req.method} ${pathname}（可用: GET /v1/models, POST /v1/chat/completions）`);
});

server.listen(PORT, HOST, () => {
  log(`askmany-proxy 已启动: http://${HOST}:${PORT}/v1`);
  log(`上游: ${UPSTREAM} | 默认模型: ${DEFAULT_MODEL} | thinking_mode: ${THINKING_MODE}`);
  log(`上游凭据: ${ASKMANY_TOKEN ? '已从配置加载' : '未配置（将透传客户端 Bearer Token）'}`);
  log(`鉴权: ${PROXY_API_KEY ? '已开启（proxy_api_key）' : '未开启（仅本机访问）'}`);
});

process.on('uncaughtException', (e) => log('[uncaught]', e.message));
process.on('unhandledRejection', (e) => log('[unhandled]', e && (e.message || e)));

{
  "port": 3000,
  "host": "127.0.0.1",
  "upstream": "https://askmany.com",
  "askmany_token": "eyJ...（从浏览器登录后的 Authorization Cookie 整体复制，含 Bearer 前缀）",
  "ama_uid": "（同上，抓 ama_uid Cookie）",
  "default_model": "deepseek-flash",
  "models": "deepseek-flash,doubao-lite,gpt-6-luna",
  "aliases": {},
  "thinking_mode": "reasoning_content",
  "proxy_api_key": "",
  "debug": "1"
}

from openai import OpenAI

client = OpenAI(base_url="http://127.0.0.1:3000/v1", api_key="anything")
resp = client.chat.completions.create(
    model="deepseek-flash",
    messages=[{"role": "user", "content": "你好"}],
    stream=True,
)
for chunk in resp:
    delta = chunk.choices[0].delta
    if getattr(delta, "reasoning_content", None):   # 思考过程
        print(delta.reasoning_content, end="", flush=True)
    if delta.content:
        print(delta.content, end="", flush=True)