使用Deno构建多种大模型AI API代理

使用 Deno 搭建大模型 API 反向代理服务#

背景介绍#

随着各大 AI 公司相继推出自己的语言模型 API 服务,开发者在使用这些服务时经常会遇到网络访问的问题。本文将介绍如何使用 Deno 搭建一个反向代理服务器,用于代理访问各种 AI 模型的 API 接口。

为什么使用 Deno#

众所周知cloudflare workers可以作为一个非常好的反向代理服务,但是它的免费版有很多限制,比如每天的请求次数有限制,还有会暴露你的ip地址等。 Deno是一个安全的运行时环境,它的安全性和性能都非常好,而且它的部署也非常简单。

更新日志#

2025.1.10 更新: 避免出现 “Unable to submit request because it must have a text parameter”
2025.4.7 更新: 添加 mistral 代理；添加 gemini 的 gemma 系列模型；更换默认模型为 gemini-2.0-flash
2025.4.16 更新: 跟随上游更新，添加工具调用
2025.5.2 更新: 添加 seed 参数支持

代码实现#

1
import { serve } from "https://deno.land/std/http/server.ts";
2
import { Buffer } from "node:buffer";
3

4
const apiMapping = {
5
  '/discord': 'https://discord.com/api',
6
  '/telegram': 'https://api.telegram.org',
7
  '/openai': 'https://api.openai.com',
8
  '/claude': 'https://api.anthropic.com',
9
  '/meta': 'https://www.meta.ai/api',
10
  '/groq': 'https://api.groq.com/openai',
11
  '/xai': 'https://api.x.ai',
12
  '/cohere': 'https://api.cohere.ai',
13
  '/huggingface': 'https://api-inference.huggingface.co',
14
  '/together': 'https://api.together.xyz',
15
  '/novita': 'https://api.novita.ai',
16
  '/portkey': 'https://api.portkey.ai',
17
  '/fireworks': 'https://api.fireworks.ai',
18
  '/openrouter': 'https://openrouter.ai/api',
19
  '/nvidia': 'https://integrate.api.nvidia.com',
20
  '/cerebras': 'https://api.cerebras.ai',
21
  '/sambanova': 'https://api.sambanova.ai',
22
  '/gemini': 'https://generativelanguage.googleapis.com',
23
  '/mistral': 'https://api.mistral.ai'
24
};
25

26
class HttpError extends Error {
27
  constructor(message, status) {
28
    super(message);
29
    this.name = this.constructor.name;
30
    this.status = status;
31
  }
32
}
33

34
const fixCors = ({ headers, status, statusText }) => {
35
  headers = new Headers(headers);
36
  headers.set("Access-Control-Allow-Origin", "*");
37
  return { headers, status, statusText };
38
};
39

40
const handleOPTIONS = async () => {
41
  return new Response(null, {
42
    headers: {
43
      "Access-Control-Allow-Origin": "*",
44
      "Access-Control-Allow-Methods": "*",
45
      "Access-Control-Allow-Headers": "*",
46
    }
47
  });
48
};
49

50
const BASE_URL = "https://generativelanguage.googleapis.com";
51
const API_VERSION = "v1beta";
52
const API_CLIENT = "genai-js/0.21.0";
53

54
const makeHeaders = (apiKey, more) => ({
55
  "x-goog-api-client": API_CLIENT,
56
  ...(apiKey && { "x-goog-api-key": apiKey }),
57
  ...more
58
});
59

60
async function handleModels(apiKey) {
61
  const response = await fetch(`${BASE_URL}/${API_VERSION}/models`, {
62
    headers: makeHeaders(apiKey),
63
  });
64
  let { body } = response;
65
  if (response.ok) {
66
    const { models } = JSON.parse(await response.text());
67
    body = JSON.stringify({
68
      object: "list",
69
      data: models.map(({ name }) => ({
70
        id: name.replace("models/", ""),
71
        object: "model",
72
        created: 0,
73
        owned_by: "",
74
      })),
75
    }, null, "  ");
76
  }
77
  return new Response(body, fixCors(response));
78
}
79

80
const DEFAULT_EMBEDDINGS_MODEL = "text-embedding-004";
81
async function handleEmbeddings(req, apiKey) {
82
  if (typeof req.model !== "string") {
83
    throw new HttpError("model is not specified", 400);
84
  }
85
  let model;
86
  if (req.model.startsWith("models/")) {
87
    model = req.model;
88
  } else {
89
  if (!req.model.startsWith("gemini-")) {
90
      req.model = DEFAULT_EMBEDDINGS_MODEL;
91
    }
92
    model = "models/" + req.model;
93
  }
94
  if (!Array.isArray(req.input)) {
95
    req.input = [ req.input ];
96
  }
97
  const response = await fetch(`${BASE_URL}/${API_VERSION}/${model}:batchEmbedContents`, {
98
    method: "POST",
99
    headers: makeHeaders(apiKey, { "Content-Type": "application/json" }),
100
    body: JSON.stringify({
101
      "requests": req.input.map(text => ({
102
        model,
103
        content: { parts: { text } },
104
        outputDimensionality: req.dimensions,
105
      }))
106
    })
107
  });
108
  let { body } = response;
109
  if (response.ok) {
110
    const { embeddings } = JSON.parse(await response.text());
111
    body = JSON.stringify({
112
      object: "list",
113
      data: embeddings.map(({ values }, index) => ({
114
        object: "embedding",
115
        index,
116
        embedding: values,
117
      })),
118
      model: req.model,
119
    }, null, "  ");
120
  }
121
  return new Response(body, fixCors(response));
122
}
123

124
const DEFAULT_MODEL = "gemini-2.0-flash";
125
async function handleCompletions(req, apiKey) {
126
  let model = DEFAULT_MODEL;
127
  switch (true) {
128
    case typeof req.model !== "string":
129
      break;
130
    case req.model.startsWith("models/"):
131
      model = req.model.substring(7);
132
      break;
133
    case req.model.startsWith("gemini-"):
134
    case req.model.startsWith("gemma-"):
135
    case req.model.startsWith("learnlm-"):
136
      model = req.model;
137
  }
138
  let body = await transformRequest(req);
139
  switch (true) {
140
    case model.endsWith(":search"):
141
      model = model.substring(0, model.length - 7);
142
      // eslint-disable-next-line no-fallthrough
143
    case req.model.endsWith("-search-preview"):
144
      body.tools = body.tools || [];
145
      body.tools.push({googleSearch: {}});
146
  }
147
  const TASK = req.stream ? "streamGenerateContent" : "generateContent";
148
  let url = `${BASE_URL}/${API_VERSION}/models/${model}:${TASK}`;
149
  if (req.stream) { url += "?alt=sse"; }
150
  const response = await fetch(url, {
151
    method: "POST",
152
    headers: makeHeaders(apiKey, { "Content-Type": "application/json" }),
153
    body: JSON.stringify(body),
154
  });
155

156
  body = response.body;
157
  if (response.ok) {
158
    let id = generateChatcmplId();
159
    if (req.stream) {
160
      body = response.body
161
        .pipeThrough(new TextDecoderStream())
162
        .pipeThrough(new TransformStream({
163
          transform: parseStream,
164
          flush: parseStreamFlush,
165
          buffer: "",
166
        }))
167
        .pipeThrough(new TransformStream({
168
          transform: toOpenAiStream,
169
          flush: toOpenAiStreamFlush,
170
          streamIncludeUsage: req.stream_options?.include_usage,
171
          model, id, last: [],
172
        }))
173
        .pipeThrough(new TextEncoderStream());
174
    } else {
175
      body = await response.text();
176
      try {
177
         body = JSON.parse(body);
178
         if (!body.candidates) {
179
           throw new Error("Invalid completion object");
180
         }
181
       } catch (err) {
182
         console.error("Error parsing response:", err);
183
         return new Response(body, fixCors(response)); // output as is
184
       }
185
       body = processCompletionsResponse(body, model, id);
186
    }
187
  }
188
  return new Response(body, fixCors(response));
189
}
190

191
const adjustProps = (schemaPart) => {
192
   if (typeof schemaPart !== "object" || schemaPart === null) {
193
     return;
194
   }
195
   if (Array.isArray(schemaPart)) {
196
     schemaPart.forEach(adjustProps);
197
   } else {
198
     if (schemaPart.type === "object" && schemaPart.properties && schemaPart.additionalProperties === false) {
199
       delete schemaPart.additionalProperties;
200
     }
201
     Object.values(schemaPart).forEach(adjustProps);
202
   }
203
 };
204
 const adjustSchema = (schema) => {
205
   const obj = schema[schema.type];
206
   delete obj.strict;
207
   return adjustProps(schema);
208
 };
209

210
const harmCategory = [
211
  "HARM_CATEGORY_HATE_SPEECH",
212
  "HARM_CATEGORY_SEXUALLY_EXPLICIT",
213
  "HARM_CATEGORY_DANGEROUS_CONTENT",
214
  "HARM_CATEGORY_HARASSMENT",
215
  "HARM_CATEGORY_CIVIC_INTEGRITY",
216
];
217

218
const safetySettings = harmCategory.map(category => ({
219
  category,
220
  threshold: "BLOCK_NONE",
221
}));
222

223
const fieldsMap = {
224
  frequency_penalty: "frequencyPenalty",
225
  max_completion_tokens: "maxOutputTokens",
226
  max_tokens: "maxOutputTokens",
227
  n: "candidateCount", // not for streaming
228
  presence_penalty: "presencePenalty",
229
  seed: "seed",
230
  stop: "stopSequences",
231
  temperature: "temperature",
232
  top_k: "topK", // non-standard
233
  top_p: "topP",
234
};
235

236
const transformConfig = (req) => {
237
  let cfg = {};
238
  for (let key in req) {
239
    const matchedKey = fieldsMap[key];
240
    if (matchedKey) {
241
      cfg[matchedKey] = req[key];
242
    }
243
  }
244
  if (req.response_format) {
245
    switch (req.response_format.type) {
246
      case "json_schema":
247
        adjustSchema(req.response_format);
248
        cfg.responseSchema = req.response_format.json_schema?.schema;
249
        if (cfg.responseSchema && "enum" in cfg.responseSchema) {
250
          cfg.responseMimeType = "text/x.enum";
251
          break;
252
        }
253
      case "json_object":
254
        cfg.responseMimeType = "application/json";
255
        break;
256
      case "text":
257
        cfg.responseMimeType = "text/plain";
258
        break;
259
      default:
260
        throw new HttpError("Unsupported response_format.type", 400);
261
    }
262
  }
263
  return cfg;
264
};
265

266
const parseImg = async (url) => {
267
  let mimeType, data;
268
  if (url.startsWith("http://") || url.startsWith("https://")) {
269
    try {
270
      const response = await fetch(url);
271
      if (!response.ok) {
272
        throw new Error(`${response.status} ${response.statusText} (${url})`);
273
      }
274
      mimeType = response.headers.get("content-type");
275
      data = Buffer.from(await response.arrayBuffer()).toString("base64");
276
    } catch (err) {
277
      throw new HttpError("Error fetching image: " + err.toString(), 400);
278
    }
279
  } else {
280
    const match = url.match(/^data:(?<mimeType>.*?)(;base64)?,(?<data>.*)$/);
281
    if (!match) {
282
      throw new HttpError("Invalid image data: " + url, 400);
283
    }
284
    ({ mimeType, data } = match.groups);
285
  }
286
  return {
287
    inlineData: {
288
      mimeType,
289
      data,
290
    },
291
  };
292
};
293

294
const transformMsg = async ({ content, tool_calls, tool_call_id }, fnames) => {
295
  const parts = [];
296
  if (tool_call_id !== undefined) {
297
    let response;
298
    try {
299
      response = JSON.parse(content);
300
    } catch (err) {
301
      console.error("Error parsing function response content:", err);
302
      throw new HttpError("Invalid function response: " + content, 400);
303
    }
304
    if (typeof response !== "object" || response === null || Array.isArray(response)) {
305
      response = { result: response };
306
    }
307
    parts.push({
308
      functionResponse: {
309
        id: tool_call_id.startsWith("{") ? null : tool_call_id,
310
        name: fnames[tool_call_id],
311
        response,
312
      }
313
    });
314
    return parts;
315
  }
316
  if (tool_calls) {
317
    for (const tcall of tool_calls) {
318
      if (tcall.type !== "function") {
319
        throw new HttpError(`Unsupported tool_call type: "${tcall.type}"`, 400);
320
      }
321
      const { function: { arguments: argstr, name }, id } = tcall;
322
      let args;
323
      try {
324
        args = JSON.parse(argstr);
325
      } catch (err) {
326
        console.error("Error parsing function arguments:", err);
327
        throw new HttpError("Invalid function arguments: " + argstr, 400);
328
      }
329
      parts.push({
330
        functionCall: {
331
          id: id.startsWith("{") ? null : id,
332
          name,
333
          args,
334
        }
335
      });
336
      fnames[id] = name;
337
    }
338
    return parts;
339
  }
340
  if (!Array.isArray(content)) {
341
    parts.push({ text: content });
342
    return parts;
343
  }
344
  for (const item of content) {
345
    switch (item.type) {
346
      case "text":
347
        parts.push({ text: item.text });
348
        break;
349
      case "image_url":
350
        parts.push(await parseImg(item.image_url.url));
351
        break;
352
      case "input_audio":
353
        parts.push({
354
          inlineData: {
355
            mimeType: "audio/" + item.input_audio.format,
356
            data: item.input_audio.data,
357
          }
358
        });
359
        break;
360
      default:
361
        throw new HttpError(`Unknown "content" item type: "${item.type}"`, 400);
362
    }
363
  }
364
  if (content.every(item => item.type === "image_url")) {
365
    parts.push({ text: "" }); // to avoid "Unable to submit request because it must have a text parameter"
366
  }
367
  return parts;
368
};
369

370
const transformMessages = async (messages) => {
371
  if (!messages) { return; }
372
  const contents = [];
373
  let system_instruction;
374
  const fnames = {}; // cache function names by tool_call_id between messages
375
  for (const item of messages) {
376
    if (item.role === "system") {
377
      delete item.role;
378
      system_instruction = { parts: await transformMsg(item) };
379
    } else {
380
      if (item.role === "assistant") {
381
        item.role = "model";
382
      } else if (item.role === "tool") {
383
      const prev = contents[contents.length - 1];
384
      if (prev?.role === "function") {
385
        prev.parts.push(...await transformMsg(item, fnames));
386
        continue;
387
      }
388
      item.role = "function"; // ignored
389
      } else if (item.role !== "user") {
390
        throw HttpError(`Unknown message role: "${item.role}"`, 400);
391
      }
392
      contents.push({
393
        role: item.role,
394
        parts: await transformMsg(item, fnames)
395
      });
396
    }
397
  }
398
  if (system_instruction) {
399
    if (!contents[0]?.parts.some(part => part.text)) {
400
      contents.unshift({ role: "user", parts: { text: " " } });
401
    }
402
  }
403
  return { system_instruction, contents };
404
};
405

406
const transformTools = (req) => {
407
   let tools, tool_config;
408
   if (req.tools) {
409
     const funcs = req.tools.filter(tool => tool.type === "function");
410
     funcs.forEach(adjustSchema);
411
     tools = [{ function_declarations: funcs.map(schema => schema.function) }];
412
   }
413
   if (req.tool_choice) {
414
     const allowed_function_names = req.tool_choice?.type === "function" ? [ req.tool_choice?.function?.name ] : undefined;
415
     if (allowed_function_names || typeof req.tool_choice === "string") {
416
       tool_config = {
417
         function_calling_config: {
418
           mode: allowed_function_names ? "ANY" : req.tool_choice.toUpperCase(),
419
           allowed_function_names
420
         }
421
       };
422
     }
423
   }
424
   return { tools, tool_config };
425
};
426

427
const transformRequest = async (req) => ({
428
  ...await transformMessages(req.messages),
429
  safetySettings,
430
  generationConfig: transformConfig(req),
431
  ...transformTools(req),
432
});
433

434
const generateChatcmplId = () => {
435
  const characters = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
436
  const randomChar = () => characters[Math.floor(Math.random() * characters.length)];
437
  return "chatcmpl-" + Array.from({ length: 29 }, randomChar).join("");
438
};
439

440
const reasonsMap = {
441
  "STOP": "stop",
442
  "MAX_TOKENS": "length",
443
  "SAFETY": "content_filter",
444
  "RECITATION": "content_filter",
445
};
446
const SEP = "\n\n|>";
447
const transformCandidates = (key, cand) => {
448
    const message = { role: "assistant", content: [] };
449
    for (const part of cand.content?.parts ?? []) {
450
      if (part.functionCall) {
451
       const fc = part.functionCall;
452
       message.tool_calls = message.tool_calls ?? [];
453
       message.tool_calls.push({
454
         id: fc.id ?? `{${fc.name}}`,
455
         type: "function",
456
         function: {
457
           name: fc.name,
458
           arguments: JSON.stringify(fc.args),
459
         }
460
       });
461
     } else {
462
       message.content.push(part.text);
463
     }
464
    }
465
    message.content = message.content.join(SEP) || null;
466
    return {
467
      index: cand.index || 0, // 0-index is absent in new -002 models response
468
      [key]: message,
469
      logprobs: null,
470
      finish_reason: message.tool_calls ? "tool_calls" : reasonsMap[cand.finishReason] || cand.finishReason,
471
      //original_finish_reason: cand.finishReason,
472
    };
473
};
474

475
const transformCandidatesMessage = transformCandidates.bind(null, "message");
476
const transformCandidatesDelta = transformCandidates.bind(null, "delta");
477

478
const transformUsage = (data) => ({
479
  completion_tokens: data.candidatesTokenCount,
480
  prompt_tokens: data.promptTokenCount,
481
  total_tokens: data.totalTokenCount
482
});
483

484
const checkPromptBlock = (choices, promptFeedback, key) => {
485
   if (choices.length) { return; }
486
   if (promptFeedback?.blockReason) {
487
     console.log("Prompt block reason:", promptFeedback.blockReason);
488
     if (promptFeedback.blockReason === "SAFETY") {
489
       promptFeedback.safetyRatings
490
         .filter(r => r.blocked)
491
         .forEach(r => console.log(r));
492
     }
493
     choices.push({
494
       index: 0,
495
       [key]: null,
496
       finish_reason: "content_filter",
497
       //original_finish_reason: data.promptFeedback.blockReason,
498
     });
499
   }
500
   return true;
501
};
502

503
const processCompletionsResponse = (data, model, id) => {
504
  const obj = {
505
    id,
506
    choices: data.candidates.map(transformCandidatesMessage),
507
    created: Math.floor(Date.now() / 1000),
508
    model: data.modelVersion ?? model,
509
    object: "chat.completion",
510
    usage: data.usageMetadata && transformUsage(data.usageMetadata),
511
  };
512
  if (obj.choices.length === 0 ) {
513
    checkPromptBlock(obj.choices, data.promptFeedback, "message");
514
  }
515
  return JSON.stringify(obj);
516
};
517

518
const responseLineRE = /^data: (.*)(?:\n\n|\r\r|\r\n\r\n)/;
519
function parseStream (chunk, controller) {
520
  this.buffer += chunk;
521
  do {
522
    const match = this.buffer.match(responseLineRE);
523
    if (!match) { break; }
524
    controller.enqueue(match[1]);
525
    this.buffer = this.buffer.substring(match[0].length);
526
  } while (true);
527
}
528

529
function parseStreamFlush (controller) {
530
  if (this.buffer) {
531
    console.error("Invalid data:", this.buffer);
532
    controller.enqueue(this.buffer);
533
  }
534
}
535

536

537
const delimiter = "\n\n";
538
const sseline = (obj) => {
539
  obj.created = Math.floor(Date.now() / 1000);
540
  return "data: " + JSON.stringify(obj) + delimiter;
541
};
542

543
function toOpenAiStream (line, controller) {
544
  let data;
545
  try {
546
    data = JSON.parse(line);
547
    if (!data.candidates) {
548
      throw new Error("Invalid completion chunk object");
549
    }
550
  } catch (err) {
551
    console.error("Error parsing response:", err);
552
    controller.enqueue(line); // output as is
553
    return;
554
  }
555

556
  const obj = {
557
    id: this.id,
558
    choices: data.candidates.map(transformCandidatesDelta),
559
    //created: Math.floor(Date.now()/1000),
560
    model: data.modelVersion ?? this.model,
561
    //system_fingerprint: "fp_69829325d0",
562
    object: "chat.completion.chunk",
563
    usage: data.usageMetadata && this.streamIncludeUsage ? null : undefined,
564
  };
565
  if (checkPromptBlock(obj.choices, data.promptFeedback, "delta")) {
566
    controller.enqueue(sseline(obj));
567
    return;
568
  }
569
  console.assert(data.candidates.length === 1, "Unexpected candidates count: %d", data.candidates.length);
570
  const cand = obj.choices[0];
571
  cand.index = cand.index || 0;
572
  const finish_reason = cand.finish_reason;
573
  cand.finish_reason = null;
574
  if (!this.last[cand.index]) { // first
575
    controller.enqueue(sseline({
576
      ...obj,
577
      choices: [{ ...cand, tool_calls: undefined, delta: { role: "assistant", content: "" } }],
578
    }));
579
  }
580
  delete cand.delta.role;
581
  if ("content" in cand.delta) { // prevent empty data (e.g. when MAX_TOKENS)
582
    controller.enqueue(sseline(obj));
583
  }
584
  cand.finish_reason = finish_reason;
585
  if (data.usageMetadata && this.streamIncludeUsage) {
586
    obj.usage = transformUsage(data.usageMetadata);
587
  }
588
  cand.delta = {};
589
  this.last[cand.index] = obj;
590
}
591

592
function toOpenAiStreamFlush (controller) {
593
  if (this.last.length > 0) {
594
    for (const obj of this.last) {
595
      controller.enqueue(sseline(obj));
596
    }
597
    controller.enqueue("data: [DONE]" + delimiter);
598
  }
599
}
600

601
const errHandler = (err) => {
602
  console.error(err);
603
  return new Response(err.message, fixCors({ status: err.status ?? 500 }));
604
};
605

606
function extractPrefixAndRest(pathname, prefixes) {
607
  for (const prefix of prefixes) {
608
    if (pathname.startsWith(prefix)) {
609
      return [prefix, pathname.slice(prefix.length)];
610
    }
611
  }
612
  return [null, null];
613
}
614

615
serve(async (request) => {
616
  const url = new URL(request.url);
617
  const pathname = url.pathname;
618

619
  if (pathname === '/' || pathname === '/index.html') {
620
    return new Response('Service is running!', {
621
      status: 200,
622
      headers: { 'Content-Type': 'text/html' }
623
    });
624
  }
625

626
  if (pathname === '/robots.txt') {
627
    return new Response('User-agent: *\nDisallow: /', {
628
      status: 200,
629
      headers: { 'Content-Type': 'text/plain' }
630
    });
631
  }
632

633
  // 特殊处理 /gemini 路径
634
  if (pathname.startsWith('/gemini')) {
635
    if (request.method === "OPTIONS") {
636
      return handleOPTIONS();
637
    }
638

639
    try {
640
      const auth = request.headers.get("Authorization");
641
      const apiKey = auth?.split(" ")[1];
642

643
      if (pathname.endsWith("/chat/completions")) {
644
        return handleCompletions(await request.json(), apiKey)
645
          .catch(errHandler);
646
      } else if (pathname.endsWith("/embeddings")) {
647
        return handleEmbeddings(await request.json(), apiKey)
648
          .catch(errHandler);
649
      } else if (pathname.endsWith("/models")) {
650
        return handleModels(apiKey)
651
          .catch(errHandler);
652
      } else {
653
        throw new HttpError("404 Not Found", 404);
654
      }
655
    } catch (err) {
656
      return errHandler(err);
657
    }
658
  }
659

660
  // 处理其他 API 路径
661
  const [prefix, rest] = extractPrefixAndRest(pathname, Object.keys(apiMapping));
662
  if (!prefix) {
663
    return new Response('Not Found', { status: 404 });
664
  }
665

666
  const targetUrl = `${apiMapping[prefix]}${rest}`;
667

668
  try {
669
    const headers = new Headers();
670
    const allowedHeaders = ['accept', 'content-type', 'authorization'];
671
    for (const [key, value] of request.headers.entries()) {
672
      if (allowedHeaders.includes(key.toLowerCase())) {
673
        headers.set(key, value);
674
      }
675
    }
676

677
    const response = await fetch(targetUrl, {
678
      method: request.method,
679
      headers: headers,
680
      body: request.body
681
    });
682

683
    const responseHeaders = new Headers(response.headers);
684
    responseHeaders.set('X-Content-Type-Options', 'nosniff');
685
    responseHeaders.set('X-Frame-Options', 'DENY');
686
    responseHeaders.set('Referrer-Policy', 'no-referrer');
687

688
    return new Response(response.body, {
689
      status: response.status,
690
      headers: responseHeaders
691
    });
692

693
  } catch (error) {
694
    console.error('Failed to fetch:', error);
695
    return new Response('Internal Server Error', { status: 500 });
696
  }
697
});

食用方法#

复制上面的代码。
打开 Deno Playground。
用github账号登录。
点击蓝色的 New Playground 按钮。
粘贴代码到左边的编辑器中。
点击上方的 Save & Deploy 按钮。
当右边的终端显示 Service is running! 时,你的服务就已经部署成功了。
在Settings中可以设置你的域名。
可以参考下面的表格,将BASE_URL改成对应的代理地址。例如: BASE_URL = "https://api.openai.com"; 改成 BASE_URL = "https://你的地址/openai"; 请求就会变成 https://你的地址/openai/v1/completions。

IMPORTANT
Gemini已经转成了Openai格式，所以Gemini的请求地址也要改成Openai格式的。不能直接使用Gemini的请求格式。如果只想单纯的代理Gemini的请求，可以部署下面的代码。

1
import { serve } from "https://deno.land/std/http/server.ts";
2

3
const apiMapping = {
4
  '/discord': 'https://discord.com/api',
5
  '/telegram': 'https://api.telegram.org',
6
  '/openai': 'https://api.openai.com',
7
  '/claude': 'https://api.anthropic.com',
8
  '/meta': 'https://www.meta.ai/api',
9
  '/groq': 'https://api.groq.com/openai',
10
  '/xai': 'https://api.x.ai',
11
  '/cohere': 'https://api.cohere.ai',
12
  '/huggingface': 'https://api-inference.huggingface.co',
13
  '/together': 'https://api.together.xyz',
14
  '/novita': 'https://api.novita.ai',
15
  '/portkey': 'https://api.portkey.ai',
16
  '/fireworks': 'https://api.fireworks.ai',
17
  '/openrouter': 'https://openrouter.ai/api',
18
  '/nvidia': 'https://integrate.api.nvidia.com',
19
  '/cerebras': 'https://api.cerebras.ai',
20
  '/sambanova': 'https://api.sambanova.ai',
21
  '/gemini': 'https://generativelanguage.googleapis.com',
22
  '/mistral': 'https://api.mistral.ai'
23
};
24

25
const CORS_HEADERS = {
26
  "access-control-allow-origin": "*",
27
  "access-control-allow-methods": "*",
28
  "access-control-allow-headers": "*",
29
};
30

31
serve(async (request) => {
32
  // 处理 CORS 预检请求
33
  if (request.method === "OPTIONS") {
34
    return new Response(null, {
35
      headers: CORS_HEADERS,
36
    });
37
  }
38

39
  const url = new URL(request.url);
40
  const pathname = url.pathname;
41

42
  if (pathname === '/' || pathname === '/index.html') {
43
    return new Response('Service is running!', {
44
      status: 200,
45
      headers: {
46
        'Content-Type': 'text/html',
47
        ...CORS_HEADERS
48
      }
49
    });
50
  }
51

52
  if (pathname === '/robots.txt') {
53
    return new Response('User-agent: *\nDisallow: /', {
54
      status: 200,
55
      headers: {
56
        'Content-Type': 'text/plain',
57
        ...CORS_HEADERS
58
      }
59
    });
60
  }
61

62
  const [prefix, rest] = extractPrefixAndRest(pathname, Object.keys(apiMapping));
63
  if (!prefix) {
64
    return new Response('Not Found', { status: 404 });
65
  }
66

67
  try {
68
    // 特殊处理 Gemini API 请求
69
    if (prefix === '/gemini') {
70
      const targetUrl = new URL(`${apiMapping[prefix]}${rest}`);
71

72
      // 转发所有查询参数
73
      url.searchParams.forEach((value, key) => {
74
        targetUrl.searchParams.append(key, value);
75
      });
76

77
      const headers = new Headers();
78
      const geminiHeaders = [
79
        'accept',
80
        'content-type',
81
        'authorization',
82
        'x-goog-api-client',
83
        'x-goog-api-key'
84
      ];
85

86
      for (const [key, value] of request.headers.entries()) {
87
        if (geminiHeaders.includes(key.toLowerCase())) {
88
          headers.set(key, value);
89
        }
90
      }
91

92
      const response = await fetch(targetUrl, {
93
        method: request.method,
94
        headers: headers,
95
        body: request.body
96
      });
97

98
      const responseHeaders = new Headers({
99
        ...CORS_HEADERS,
100
        ...Object.fromEntries(response.headers),
101
        'X-Content-Type-Options': 'nosniff',
102
        'X-Frame-Options': 'DENY',
103
        'Referrer-Policy': 'no-referrer'
104
      });
105

106
      return new Response(response.body, {
107
        status: response.status,
108
        headers: responseHeaders
109
      });
110
    }
111

112
    // 处理其他 API 请求
113
    const targetUrl = `${apiMapping[prefix]}${rest}`;
114
    const headers = new Headers();
115
    const allowedHeaders = ['accept', 'content-type', 'authorization'];
116

117
    for (const [key, value] of request.headers.entries()) {
118
      if (allowedHeaders.includes(key.toLowerCase())) {
119
        headers.set(key, value);
120
      }
121
    }
122

123
    const response = await fetch(targetUrl, {
124
      method: request.method,
125
      headers: headers,
126
      body: request.body
127
    });
128

129
    const responseHeaders = new Headers(response.headers);
130
    responseHeaders.set('X-Content-Type-Options', 'nosniff');
131
    responseHeaders.set('X-Frame-Options', 'DENY');
132
    responseHeaders.set('Referrer-Policy', 'no-referrer');
133

134
    // 添加 CORS 头
135
    Object.entries(CORS_HEADERS).forEach(([key, value]) => {
136
      responseHeaders.set(key, value);
137
    });
138

139
    return new Response(response.body, {
140
      status: response.status,
141
      headers: responseHeaders
142
    });
143

144
  } catch (error) {
145
    console.error('Failed to fetch:', error);
146
    return new Response('Internal Server Error', { status: 500 });
147
  }
148
});
149

150
function extractPrefixAndRest(pathname: string, prefixes: string[]): [string | null, string | null] {
151
  for (const prefix of prefixes) {
152
    if (pathname.startsWith(prefix)) {
153
      return [prefix, pathname.slice(prefix.length)];
154
    }
155
  }
156
  return [null, null];
157
}

代理地址#

代理地址	源地址
`https://你的地址/anthropic`	`https://api.anthropic.com`
`https://你的地址/cerebras`	`https://api.cerebras.ai`
`https://你的地址/cohere`	`https://api.cohere.ai`
`https://你的地址/discord`	`https://discord.com/api`
`https://你的地址/fireworks`	`https://api.fireworks.ai`
`https://你的地址/gemini`	`https://generativelanguage.googleapis.com`
`https://你的地址/groq`	`https://api.groq.com/openai`
`https://你的地址/huggingface`	`https://api-inference.huggingface.co`
`https://你的地址/meta`	`https://www.meta.ai/api`
`https://你的地址/novita`	`https://api.novita.ai`
`https://你的地址/nvidia`	`https://integrate.api.nvidia.com`
`https://你的地址/openai`	`https://api.openai.com`
`https://你的地址/openrouter`	`https://openrouter.ai/api`
`https://你的地址/portkey`	`https://api.portkey.ai`
`https://你的地址/telegram`	`https://api.telegram.org`
`https://你的地址/together`	`https://api.together.xyz`
`https://你的地址/xai`	`https://api.x.ai`
`https://你的地址/sambanova`	`https://api.sambanova.ai`
`https://你的地址/mistral`	`https://api.mistral.ai`

参考项目#

PublicAffairs

openai-gemini

Waiting for api.github.com...

00K

Waiting...