Upload 12 files

auth.ts

@@ -0,0 +1,15 @@
+// auth.ts
+import { getToken } from "./utils.ts";
+import { unauthorizedResponse } from "./response.ts";
+
+export function validateAuth(req: Request): Response | null {
+  const token = getToken();
+  if (!token) return null; // 无需认证
+  
+  const auth = req.headers.get("authorization") ?? "";
+  if (auth !== token) {
+    return unauthorizedResponse("无效的客户端 API 密钥", 403);
+  }
+  
+  return null; // 认证通过
+}

ddg-service.ts

@@ -0,0 +1,146 @@
+import { generateVqdHash } from "./vm.ts";
+import { userAgent } from "./utils.ts";
+import { CONFIG, getHash, setHash } from "./utils.ts";
+import { ChatMessage } from "./types.ts";
+import { errorResponse } from "./response.ts";
+
+export class DDGService {
+  private hash: string | null = null;
+
+  async getVqdHash(): Promise<string | Response> {
+    // 优先使用环境变量中的hash
+    const envHash = getHash();
+    if (envHash) {
+      return envHash;
+    }
+
+    try {
+      const response = await fetch(CONFIG.DDG_STATUS_URL, {
+        method: "GET",
+        headers: {
+          "User-Agent": userAgent,
+          "x-vqd-accept": "1",
+        },
+      });
+
+      if (!response.ok) {
+        return errorResponse(`hash初始化请求失败: ${response.status}`, 502);
+      }
+
+      const hash = response.headers.get("x-vqd-hash-1");
+
+      if (!hash) {
+        return errorResponse(`未找到hash头部，状态码: ${response.status}`, 502);
+      }
+
+      let decryptedHash: string;
+      try {
+        decryptedHash = generateVqdHash(hash);
+      } catch (decryptError) {
+        return errorResponse(`hash解密失败: ${decryptError.message}`, 502);
+      }
+
+      if (!decryptedHash || decryptedHash.trim() === "") {
+        return errorResponse(`hash解密结果为空`, 502);
+      }
+      setHash(decryptedHash);
+      return decryptedHash;
+    } catch (error) {
+      return errorResponse(`获取hash失败: ${error.message}`, 502);
+    }
+  }
+
+  // 内部发送消息方法，返回具体的错误信息
+  private async sendMessage(
+    model: string,
+    messages: ChatMessage[]
+  ): Promise<{
+    success: boolean;
+    response?: Response;
+    error?: string;
+    status?: number;
+  }> {
+    const hash = await this.getVqdHash();
+    if (hash instanceof Response) {
+      return { success: false, error: "获取hash失败", status: hash.status };
+    }
+
+    const payload = {
+      model,
+      messages,
+      canUseTools: false,
+      canUseApproxLocation: false,
+    };
+
+    try {
+      const response = await fetch(CONFIG.DDG_CHAT_URL, {
+        method: "POST",
+        headers: {
+          "User-Agent": userAgent,
+          "x-vqd-hash-1": hash,
+          "Content-Type": "application/json",
+        },
+        body: JSON.stringify(payload),
+      });
+
+      if (!response.ok) {
+        const errorText = await response.text();
+        return {
+          success: false,
+          error: `上游错误: ${response.status} - ${errorText}`,
+          status: response.status,
+        };
+      }
+
+      return { success: true, response };
+    } catch (error) {
+      return {
+        success: false,
+        error: `请求失败: ${error.message}`,
+        status: 502,
+      };
+    }
+  }
+
+  // 带重试机制的发送消息方法 - 只对418错误重试
+  async sendMessageWithRetry(
+    model: string,
+    messages: ChatMessage[],
+    maxRetries = 1
+  ): Promise<Response> {
+    let lastResult: {
+      success: boolean;
+      response?: Response;
+      error?: string;
+      status?: number;
+    } | null = null;
+
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+      if (attempt > 0) {
+        setHash(""); // 重置hash，强制重新获取
+      }
+
+      const result = await this.sendMessage(model, messages);
+
+      if (result.success && result.response) {
+        return result.response;
+      }
+
+      lastResult = result;
+
+      // 只有418错误才重试
+      if (result.status === 418 || 429) {
+        continue;
+      } else {
+        // 其他错误直接返回，不重试
+        break;
+      }
+    }
+
+    // 返回最后一次的错误
+    return errorResponse(
+      lastResult?.error || "发送消息失败",
+      lastResult?.status || 502
+    );
+  }
+}

deno.lock

@@ -0,0 +1,14 @@
+{
+  "version": "5",
+  "remote": {
+    "https://deno.land/[email protected]/async/delay.ts": "f90dd685b97c2f142b8069082993e437b1602b8e2561134827eeb7c12b95c499",
+    "https://deno.land/[email protected]/http/server.ts": "f9313804bf6467a1704f45f76cb6cd0a3396a3b31c316035e6a4c2035d1ea514"
+  },
+  "workspace": {
+    "packageJson": {
+      "dependencies": [
+        "npm:jsdom@^26.1.0"
+      ]
+    }
+  }
+}

handlers.ts

@@ -0,0 +1,57 @@
+// handlers.ts
+import { CONFIG } from "./utils.ts";
+import { ChatCompletionRequest, ModelInfo } from "./types.ts";
+import { errorResponse, ResponseBuilder } from "./response.ts";
+import { validateAuth } from "./auth.ts";
+import { DDGService } from "./ddg-service.ts";
+
+const ddgService = new DDGService();
+
+export async function handleModels(req: Request): Promise<Response> {
+  const data: ModelInfo[] = CONFIG.MODELS.map((id) => ({
+    id,
+    object: "model",
+    created: 0,
+    owned_by: "ddg",
+  }));
+  
+  return ResponseBuilder.jsonResponse({ object: "list", data });
+}
+
+export async function handleChatCompletions(req: Request): Promise<Response> {
+  // 认证检查
+  const authError = validateAuth(req);
+  if (authError) return authError;
+
+  // 解析请求体
+  let body: ChatCompletionRequest;
+  try {
+    const bodyText = await req.text();
+    body = JSON.parse(bodyText);
+  } catch {
+    return errorResponse("请求 JSON 解析失败", 400);
+  }
+
+  // 验证模型
+  const { model, messages, stream = false } = body;
+  if (!CONFIG.MODELS.includes(model)) {
+    return errorResponse(`模型 ${model} 未找到`, 404);
+  }
+
+  // 发送到DDG
+  const ddgResponse = await ddgService.sendMessageWithRetry(model, messages);
+  if (!ddgResponse.ok) {
+    return ddgResponse;
+  }
+
+  return ResponseBuilder.buildResponse(ddgResponse.body!,stream,model);
+}
+
+export const handleMeow = async (request: Request): Promise<Response> => {
+    return new Response("Meow~", {
+      status: 200,
+      headers: {
+        "Content-Type": "text/plain",
+      },
+    });
+};

main.ts

@@ -0,0 +1,8 @@
+// main.ts
+import { serve } from "https://deno.land/[email protected]/http/server.ts";
+import { router } from "./router.ts";
+import { CONFIG } from "./utils.ts";
+
+console.log(`🚀 服务器启动在端口 ${CONFIG.PORT}`);
+
+serve((req: Request) => router(req), { port: CONFIG.PORT });

package-lock.json

@@ -0,0 +1,502 @@
+{
+  "name": "duckduckgo",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "dependencies": {
+        "jsdom": "^26.1.0"
+      }
+    },
+    "node_modules/@asamuzakjp/css-color": {
+      "version": "3.2.0",
+      "resolved": "https://registry.npmjs.org/@asamuzakjp/css-color/-/css-color-3.2.0.tgz",
+      "integrity": "sha512-K1A6z8tS3XsmCMM86xoWdn7Fkdn9m6RSVtocUrJYIwZnFVkng/PvkEoWtOWmP+Scc6saYWHWZYbndEEXxl24jw==",
+      "license": "MIT",
+      "dependencies": {
+        "@csstools/css-calc": "^2.1.3",
+        "@csstools/css-color-parser": "^3.0.9",
+        "@csstools/css-parser-algorithms": "^3.0.4",
+        "@csstools/css-tokenizer": "^3.0.3",
+        "lru-cache": "^10.4.3"
+      }
+    },
+    "node_modules/@csstools/color-helpers": {
+      "version": "5.0.2",
+      "resolved": "https://registry.npmjs.org/@csstools/color-helpers/-/color-helpers-5.0.2.tgz",
+      "integrity": "sha512-JqWH1vsgdGcw2RR6VliXXdA0/59LttzlU8UlRT/iUUsEeWfYq8I+K0yhihEUTTHLRm1EXvpsCx3083EU15ecsA==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/csstools"
+        },
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/csstools"
+        }
+      ],
+      "license": "MIT-0",
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@csstools/css-calc": {
+      "version": "2.1.4",
+      "resolved": "https://registry.npmjs.org/@csstools/css-calc/-/css-calc-2.1.4.tgz",
+      "integrity": "sha512-3N8oaj+0juUw/1H3YwmDDJXCgTB1gKU6Hc/bB502u9zR0q2vd786XJH9QfrKIEgFlZmhZiq6epXl4rHqhzsIgQ==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/csstools"
+        },
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/csstools"
+        }
+      ],
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      },
+      "peerDependencies": {
+        "@csstools/css-parser-algorithms": "^3.0.5",
+        "@csstools/css-tokenizer": "^3.0.4"
+      }
+    },
+    "node_modules/@csstools/css-color-parser": {
+      "version": "3.0.10",
+      "resolved": "https://registry.npmjs.org/@csstools/css-color-parser/-/css-color-parser-3.0.10.tgz",
+      "integrity": "sha512-TiJ5Ajr6WRd1r8HSiwJvZBiJOqtH86aHpUjq5aEKWHiII2Qfjqd/HCWKPOW8EP4vcspXbHnXrwIDlu5savQipg==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/csstools"
+        },
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/csstools"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "@csstools/color-helpers": "^5.0.2",
+        "@csstools/css-calc": "^2.1.4"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "peerDependencies": {
+        "@csstools/css-parser-algorithms": "^3.0.5",
+        "@csstools/css-tokenizer": "^3.0.4"
+      }
+    },
+    "node_modules/@csstools/css-parser-algorithms": {
+      "version": "3.0.5",
+      "resolved": "https://registry.npmjs.org/@csstools/css-parser-algorithms/-/css-parser-algorithms-3.0.5.tgz",
+      "integrity": "sha512-DaDeUkXZKjdGhgYaHNJTV9pV7Y9B3b644jCLs9Upc3VeNGg6LWARAT6O+Q+/COo+2gg/bM5rhpMAtf70WqfBdQ==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/csstools"
+        },
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/csstools"
+        }
+      ],
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      },
+      "peerDependencies": {
+        "@csstools/css-tokenizer": "^3.0.4"
+      }
+    },
+    "node_modules/@csstools/css-tokenizer": {
+      "version": "3.0.4",
+      "resolved": "https://registry.npmjs.org/@csstools/css-tokenizer/-/css-tokenizer-3.0.4.tgz",
+      "integrity": "sha512-Vd/9EVDiu6PPJt9yAh6roZP6El1xHrdvIVGjyBsHR0RYwNHgL7FJPyIIW4fANJNG6FtyZfvlRPpFI4ZM/lubvw==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/csstools"
+        },
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/csstools"
+        }
+      ],
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/agent-base": {
+      "version": "7.1.3",
+      "resolved": "https://registry.npmjs.org/agent-base/-/agent-base-7.1.3.tgz",
+      "integrity": "sha512-jRR5wdylq8CkOe6hei19GGZnxM6rBGwFl3Bg0YItGDimvjGtAvdZk4Pu6Cl4u4Igsws4a1fd1Vq3ezrhn4KmFw==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 14"
+      }
+    },
+    "node_modules/cssstyle": {
+      "version": "4.6.0",
+      "resolved": "https://registry.npmjs.org/cssstyle/-/cssstyle-4.6.0.tgz",
+      "integrity": "sha512-2z+rWdzbbSZv6/rhtvzvqeZQHrBaqgogqt85sqFNbabZOuFbCVFb8kPeEtZjiKkbrm395irpNKiYeFeLiQnFPg==",
+      "license": "MIT",
+      "dependencies": {
+        "@asamuzakjp/css-color": "^3.2.0",
+        "rrweb-cssom": "^0.8.0"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/data-urls": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/data-urls/-/data-urls-5.0.0.tgz",
+      "integrity": "sha512-ZYP5VBHshaDAiVZxjbRVcFJpc+4xGgT0bK3vzy1HLN8jTO975HEbuYzZJcHoQEY5K1a0z8YayJkyVETa08eNTg==",
+      "license": "MIT",
+      "dependencies": {
+        "whatwg-mimetype": "^4.0.0",
+        "whatwg-url": "^14.0.0"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/debug": {
+      "version": "4.4.1",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.1.tgz",
+      "integrity": "sha512-KcKCqiftBJcZr++7ykoDIEwSa3XWowTfNPo92BYxjXiyYEVrUQh2aLyhxBCwww+heortUFxEJYcRzosstTEBYQ==",
+      "license": "MIT",
+      "dependencies": {
+        "ms": "^2.1.3"
+      },
+      "engines": {
+        "node": ">=6.0"
+      },
+      "peerDependenciesMeta": {
+        "supports-color": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/decimal.js": {
+      "version": "10.6.0",
+      "resolved": "https://registry.npmjs.org/decimal.js/-/decimal.js-10.6.0.tgz",
+      "integrity": "sha512-YpgQiITW3JXGntzdUmyUR1V812Hn8T1YVXhCu+wO3OpS4eU9l4YdD3qjyiKdV6mvV29zapkMeD390UVEf2lkUg==",
+      "license": "MIT"
+    },
+    "node_modules/entities": {
+      "version": "6.0.1",
+      "resolved": "https://registry.npmjs.org/entities/-/entities-6.0.1.tgz",
+      "integrity": "sha512-aN97NXWF6AWBTahfVOIrB/NShkzi5H7F9r1s9mD3cDj4Ko5f2qhhVoYMibXF7GlLveb/D2ioWay8lxI97Ven3g==",
+      "license": "BSD-2-Clause",
+      "engines": {
+        "node": ">=0.12"
+      },
+      "funding": {
+        "url": "https://github.com/fb55/entities?sponsor=1"
+      }
+    },
+    "node_modules/html-encoding-sniffer": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/html-encoding-sniffer/-/html-encoding-sniffer-4.0.0.tgz",
+      "integrity": "sha512-Y22oTqIU4uuPgEemfz7NDJz6OeKf12Lsu+QC+s3BVpda64lTiMYCyGwg5ki4vFxkMwQdeZDl2adZoqUgdFuTgQ==",
+      "license": "MIT",
+      "dependencies": {
+        "whatwg-encoding": "^3.1.1"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/http-proxy-agent": {
+      "version": "7.0.2",
+      "resolved": "https://registry.npmjs.org/http-proxy-agent/-/http-proxy-agent-7.0.2.tgz",
+      "integrity": "sha512-T1gkAiYYDWYx3V5Bmyu7HcfcvL7mUrTWiM6yOfa3PIphViJ/gFPbvidQ+veqSOHci/PxBcDabeUNCzpOODJZig==",
+      "license": "MIT",
+      "dependencies": {
+        "agent-base": "^7.1.0",
+        "debug": "^4.3.4"
+      },
+      "engines": {
+        "node": ">= 14"
+      }
+    },
+    "node_modules/https-proxy-agent": {
+      "version": "7.0.6",
+      "resolved": "https://registry.npmjs.org/https-proxy-agent/-/https-proxy-agent-7.0.6.tgz",
+      "integrity": "sha512-vK9P5/iUfdl95AI+JVyUuIcVtd4ofvtrOr3HNtM2yxC9bnMbEdp3x01OhQNnjb8IJYi38VlTE3mBXwcfvywuSw==",
+      "license": "MIT",
+      "dependencies": {
+        "agent-base": "^7.1.2",
+        "debug": "4"
+      },
+      "engines": {
+        "node": ">= 14"
+      }
+    },
+    "node_modules/iconv-lite": {
+      "version": "0.6.3",
+      "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.6.3.tgz",
+      "integrity": "sha512-4fCk79wshMdzMp2rH06qWrJE4iolqLhCUH+OiuIgU++RB0+94NlDL81atO7GX55uUKueo0txHNtvEyI6D7WdMw==",
+      "license": "MIT",
+      "dependencies": {
+        "safer-buffer": ">= 2.1.2 < 3.0.0"
+      },
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/is-potential-custom-element-name": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/is-potential-custom-element-name/-/is-potential-custom-element-name-1.0.1.tgz",
+      "integrity": "sha512-bCYeRA2rVibKZd+s2625gGnGF/t7DSqDs4dP7CrLA1m7jKWz6pps0LpYLJN8Q64HtmPKJ1hrN3nzPNKFEKOUiQ==",
+      "license": "MIT"
+    },
+    "node_modules/jsdom": {
+      "version": "26.1.0",
+      "resolved": "https://registry.npmjs.org/jsdom/-/jsdom-26.1.0.tgz",
+      "integrity": "sha512-Cvc9WUhxSMEo4McES3P7oK3QaXldCfNWp7pl2NNeiIFlCoLr3kfq9kb1fxftiwk1FLV7CvpvDfonxtzUDeSOPg==",
+      "license": "MIT",
+      "dependencies": {
+        "cssstyle": "^4.2.1",
+        "data-urls": "^5.0.0",
+        "decimal.js": "^10.5.0",
+        "html-encoding-sniffer": "^4.0.0",
+        "http-proxy-agent": "^7.0.2",
+        "https-proxy-agent": "^7.0.6",
+        "is-potential-custom-element-name": "^1.0.1",
+        "nwsapi": "^2.2.16",
+        "parse5": "^7.2.1",
+        "rrweb-cssom": "^0.8.0",
+        "saxes": "^6.0.0",
+        "symbol-tree": "^3.2.4",
+        "tough-cookie": "^5.1.1",
+        "w3c-xmlserializer": "^5.0.0",
+        "webidl-conversions": "^7.0.0",
+        "whatwg-encoding": "^3.1.1",
+        "whatwg-mimetype": "^4.0.0",
+        "whatwg-url": "^14.1.1",
+        "ws": "^8.18.0",
+        "xml-name-validator": "^5.0.0"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "peerDependencies": {
+        "canvas": "^3.0.0"
+      },
+      "peerDependenciesMeta": {
+        "canvas": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/lru-cache": {
+      "version": "10.4.3",
+      "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-10.4.3.tgz",
+      "integrity": "sha512-JNAzZcXrCt42VGLuYz0zfAzDfAvJWW6AfYlDBQyDV5DClI2m5sAmK+OIO7s59XfsRsWHp02jAJrRadPRGTt6SQ==",
+      "license": "ISC"
+    },
+    "node_modules/ms": {
+      "version": "2.1.3",
+      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
+      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
+      "license": "MIT"
+    },
+    "node_modules/nwsapi": {
+      "version": "2.2.20",
+      "resolved": "https://registry.npmjs.org/nwsapi/-/nwsapi-2.2.20.tgz",
+      "integrity": "sha512-/ieB+mDe4MrrKMT8z+mQL8klXydZWGR5Dowt4RAGKbJ3kIGEx3X4ljUo+6V73IXtUPWgfOlU5B9MlGxFO5T+cA==",
+      "license": "MIT"
+    },
+    "node_modules/parse5": {
+      "version": "7.3.0",
+      "resolved": "https://registry.npmjs.org/parse5/-/parse5-7.3.0.tgz",
+      "integrity": "sha512-IInvU7fabl34qmi9gY8XOVxhYyMyuH2xUNpb2q8/Y+7552KlejkRvqvD19nMoUW/uQGGbqNpA6Tufu5FL5BZgw==",
+      "license": "MIT",
+      "dependencies": {
+        "entities": "^6.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/inikulin/parse5?sponsor=1"
+      }
+    },
+    "node_modules/punycode": {
+      "version": "2.3.1",
+      "resolved": "https://registry.npmjs.org/punycode/-/punycode-2.3.1.tgz",
+      "integrity": "sha512-vYt7UD1U9Wg6138shLtLOvdAu+8DsC/ilFtEVHcH+wydcSpNE20AfSOduf6MkRFahL5FY7X1oU7nKVZFtfq8Fg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/rrweb-cssom": {
+      "version": "0.8.0",
+      "resolved": "https://registry.npmjs.org/rrweb-cssom/-/rrweb-cssom-0.8.0.tgz",
+      "integrity": "sha512-guoltQEx+9aMf2gDZ0s62EcV8lsXR+0w8915TC3ITdn2YueuNjdAYh/levpU9nFaoChh9RUS5ZdQMrKfVEN9tw==",
+      "license": "MIT"
+    },
+    "node_modules/safer-buffer": {
+      "version": "2.1.2",
+      "resolved": "https://registry.npmjs.org/safer-buffer/-/safer-buffer-2.1.2.tgz",
+      "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==",
+      "license": "MIT"
+    },
+    "node_modules/saxes": {
+      "version": "6.0.0",
+      "resolved": "https://registry.npmjs.org/saxes/-/saxes-6.0.0.tgz",
+      "integrity": "sha512-xAg7SOnEhrm5zI3puOOKyy1OMcMlIJZYNJY7xLBwSze0UjhPLnWfj2GF2EpT0jmzaJKIWKHLsaSSajf35bcYnA==",
+      "license": "ISC",
+      "dependencies": {
+        "xmlchars": "^2.2.0"
+      },
+      "engines": {
+        "node": ">=v12.22.7"
+      }
+    },
+    "node_modules/symbol-tree": {
+      "version": "3.2.4",
+      "resolved": "https://registry.npmjs.org/symbol-tree/-/symbol-tree-3.2.4.tgz",
+      "integrity": "sha512-9QNk5KwDF+Bvz+PyObkmSYjI5ksVUYtjW7AU22r2NKcfLJcXp96hkDWU3+XndOsUb+AQ9QhfzfCT2O+CNWT5Tw==",
+      "license": "MIT"
+    },
+    "node_modules/tldts": {
+      "version": "6.1.86",
+      "resolved": "https://registry.npmjs.org/tldts/-/tldts-6.1.86.tgz",
+      "integrity": "sha512-WMi/OQ2axVTf/ykqCQgXiIct+mSQDFdH2fkwhPwgEwvJ1kSzZRiinb0zF2Xb8u4+OqPChmyI6MEu4EezNJz+FQ==",
+      "license": "MIT",
+      "dependencies": {
+        "tldts-core": "^6.1.86"
+      },
+      "bin": {
+        "tldts": "bin/cli.js"
+      }
+    },
+    "node_modules/tldts-core": {
+      "version": "6.1.86",
+      "resolved": "https://registry.npmjs.org/tldts-core/-/tldts-core-6.1.86.tgz",
+      "integrity": "sha512-Je6p7pkk+KMzMv2XXKmAE3McmolOQFdxkKw0R8EYNr7sELW46JqnNeTX8ybPiQgvg1ymCoF8LXs5fzFaZvJPTA==",
+      "license": "MIT"
+    },
+    "node_modules/tough-cookie": {
+      "version": "5.1.2",
+      "resolved": "https://registry.npmjs.org/tough-cookie/-/tough-cookie-5.1.2.tgz",
+      "integrity": "sha512-FVDYdxtnj0G6Qm/DhNPSb8Ju59ULcup3tuJxkFb5K8Bv2pUXILbf0xZWU8PX8Ov19OXljbUyveOFwRMwkXzO+A==",
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "tldts": "^6.1.32"
+      },
+      "engines": {
+        "node": ">=16"
+      }
+    },
+    "node_modules/tr46": {
+      "version": "5.1.1",
+      "resolved": "https://registry.npmjs.org/tr46/-/tr46-5.1.1.tgz",
+      "integrity": "sha512-hdF5ZgjTqgAntKkklYw0R03MG2x/bSzTtkxmIRw/sTNV8YXsCJ1tfLAX23lhxhHJlEf3CRCOCGGWw3vI3GaSPw==",
+      "license": "MIT",
+      "dependencies": {
+        "punycode": "^2.3.1"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/w3c-xmlserializer": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/w3c-xmlserializer/-/w3c-xmlserializer-5.0.0.tgz",
+      "integrity": "sha512-o8qghlI8NZHU1lLPrpi2+Uq7abh4GGPpYANlalzWxyWteJOCsr/P+oPBA49TOLu5FTZO4d3F9MnWJfiMo4BkmA==",
+      "license": "MIT",
+      "dependencies": {
+        "xml-name-validator": "^5.0.0"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/webidl-conversions": {
+      "version": "7.0.0",
+      "resolved": "https://registry.npmjs.org/webidl-conversions/-/webidl-conversions-7.0.0.tgz",
+      "integrity": "sha512-VwddBukDzu71offAQR975unBIGqfKZpM+8ZX6ySk8nYhVoo5CYaZyzt3YBvYtRtO+aoGlqxPg/B87NGVZ/fu6g==",
+      "license": "BSD-2-Clause",
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/whatwg-encoding": {
+      "version": "3.1.1",
+      "resolved": "https://registry.npmjs.org/whatwg-encoding/-/whatwg-encoding-3.1.1.tgz",
+      "integrity": "sha512-6qN4hJdMwfYBtE3YBTTHhoeuUrDBPZmbQaxWAqSALV/MeEnR5z1xd8UKud2RAkFoPkmB+hli1TZSnyi84xz1vQ==",
+      "license": "MIT",
+      "dependencies": {
+        "iconv-lite": "0.6.3"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/whatwg-mimetype": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/whatwg-mimetype/-/whatwg-mimetype-4.0.0.tgz",
+      "integrity": "sha512-QaKxh0eNIi2mE9p2vEdzfagOKHCcj1pJ56EEHGQOVxp8r9/iszLUUV7v89x9O1p/T+NlTM5W7jW6+cz4Fq1YVg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/whatwg-url": {
+      "version": "14.2.0",
+      "resolved": "https://registry.npmjs.org/whatwg-url/-/whatwg-url-14.2.0.tgz",
+      "integrity": "sha512-De72GdQZzNTUBBChsXueQUnPKDkg/5A5zp7pFDuQAj5UFoENpiACU0wlCvzpAGnTkj++ihpKwKyYewn/XNUbKw==",
+      "license": "MIT",
+      "dependencies": {
+        "tr46": "^5.1.0",
+        "webidl-conversions": "^7.0.0"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/ws": {
+      "version": "8.18.3",
+      "resolved": "https://registry.npmjs.org/ws/-/ws-8.18.3.tgz",
+      "integrity": "sha512-PEIGCY5tSlUt50cqyMXfCzX+oOPqN0vuGqWzbcJ2xvnkzkq46oOpz7dQaTDBdfICb4N14+GARUDw2XV2N4tvzg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=10.0.0"
+      },
+      "peerDependencies": {
+        "bufferutil": "^4.0.1",
+        "utf-8-validate": ">=5.0.2"
+      },
+      "peerDependenciesMeta": {
+        "bufferutil": {
+          "optional": true
+        },
+        "utf-8-validate": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/xml-name-validator": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/xml-name-validator/-/xml-name-validator-5.0.0.tgz",
+      "integrity": "sha512-EvGK8EJ3DhaHfbRlETOWAS5pO9MZITeauHKJyb8wyajUfQUenkIg2MvLDTZ4T/TgIcm3HU0TFBgWWboAZ30UHg==",
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/xmlchars": {
+      "version": "2.2.0",
+      "resolved": "https://registry.npmjs.org/xmlchars/-/xmlchars-2.2.0.tgz",
+      "integrity": "sha512-JZnDKK8B0RCDw84FNdDAIpZK+JuJw+s7Lz8nksI7SIuU3UXJJslUthsi+uWBUYOwPFwW7W7PRLRfUKpxjtjFCw==",
+      "license": "MIT"
+    }
+  }
+}

package.json

@@ -0,0 +1,5 @@
+{
+  "dependencies": {
+    "jsdom": "^26.1.0"
+  }
+}

response.ts

@@ -0,0 +1,231 @@
+import { ServerRequest } from "https://deno.land/[email protected]/http/server.ts";
+
+interface OpenAIChoice {
+  index: number;
+  message?: {
+    role: string;
+    content: string;
+  };
+  delta?: {
+    content: string;
+  };
+  finish_reason: string | null;
+}
+interface OpenAIUsage {
+  prompt_tokens: number;
+  completion_tokens: number;
+  total_tokens: number;
+}
+interface OpenAIResponse {
+  id: string;
+  object: string;
+  created: number;
+  model: string;
+  choices: OpenAIChoice[];
+  usage?: OpenAIUsage;
+}
+export class ResponseBuilder {
+  private static log(
+    level: "info" | "warn" | "error",
+    message: string,
+    data?: any
+  ) {
+    const timestamp = new Date().toISOString();
+    const logData = data ? ` | Data: ${JSON.stringify(data)}` : "";
+    console[level](`[${timestamp}] [ResponseBuilder] ${message}${logData}`);
+  }
+
+  // 构建非流式响应
+  static buildNonStreamResponse(
+    modelName: string,
+    fullContent: string,
+    finishReason: string = "stop"
+  ): Response {
+    this.log("info", "Building non-stream response", {
+      modelName,
+      contentLength: fullContent.length,
+    });
+
+    const response = {
+      id: "Chat-Nekohy",
+      object: "chat.completion",
+      created: Math.floor(Date.now() / 1000),
+      model: modelName,
+      choices: [
+        {
+          index: 0,
+          message: { role: "assistant", content: fullContent },
+          finish_reason: finishReason,
+        },
+      ],
+    };
+
+    return new Response(JSON.stringify(response), {
+      status: 200,
+      headers: { "Content-Type": "application/json" },
+    });
+  }
+
+  // 构建SSE数据块
+  static buildSSEChunk(
+    model: string,
+    content: string,
+    isFinish: boolean = false
+  ): string {
+    const response = {
+      id: "chatcmpl-Nekohy",
+      object: "chat.completion.chunk",
+      created: Math.floor(Date.now() / 1000),
+      model,
+      choices: [
+        {
+          index: 0,
+          delta: isFinish ? {} : { content },
+          finish_reason: isFinish ? "stop" : null,
+        },
+      ],
+    };
+
+    const chunk = `data: ${JSON.stringify(response)}\n\n`;
+    return isFinish ? chunk + "data: [DONE]\n\n" : chunk;
+  }
+
+  // 主要响应构建方法
+  static buildResponse(
+    readableStream: ReadableStream,
+    stream: boolean = false,
+    modelName: string = "default"
+  ): Response {
+    this.log("info", "Building response", { stream, modelName });
+
+    const transformedStream = new ReadableStream({
+      start: async (controller) => {
+        const reader = readableStream.getReader();
+        const decoder = new TextDecoder();
+        let fullContent = "";
+        let chunkCount = 0;
+
+        try {
+          while (true) {
+            const { done, value } = await reader.read();
+            if (done) break;
+
+            const chunk = decoder.decode(value, { stream: true });
+            const content = this.extractContent(chunk);
+
+            if (content) {
+              chunkCount++;
+              fullContent += content;
+
+              if (stream) {
+                const sseChunk = this.buildSSEChunk(modelName, content);
+                controller.enqueue(new TextEncoder().encode(sseChunk));
+              }
+            }
+          }
+
+          this.log("info", "Stream processing completed", {
+            chunkCount,
+            totalLength: fullContent.length,
+            stream,
+          });
+
+          if (stream) {
+            // 发送结束标记
+            const finishChunk = this.buildSSEChunk(modelName, "", true);
+            controller.enqueue(new TextEncoder().encode(finishChunk));
+          } else {
+            // 发送完整响应
+            const response = this.buildNonStreamResponse(
+              modelName,
+              fullContent
+            );
+            const responseText = await response.text();
+            controller.enqueue(new TextEncoder().encode(responseText));
+          }
+
+          controller.close();
+        } catch (error) {
+          this.log("error", "Stream processing failed", {
+            error: error.message,
+          });
+          controller.error(error);
+        } finally {
+          reader.releaseLock();
+        }
+      },
+    });
+
+    const headers = stream
+      ? {
+          "Content-Type": "text/event-stream",
+          Connection: "keep-alive",
+          "Cache-Control": "no-cache",
+        }
+      : { "Content-Type": "application/json" };
+
+    return new Response(transformedStream, { status: 200, headers });
+  }
+
+  // 提取SSE数据中的内容
+  private static extractContent(chunk: string): string {
+    let content = "";
+    const lines = chunk.split("\n");
+
+    for (const line of lines) {
+      const trimmedLine = line.trim();
+      if (trimmedLine.startsWith("data: ") && !trimmedLine.includes("[DONE]")) {
+        try {
+          const jsonStr = trimmedLine.slice(6).trim();
+          if (jsonStr) {
+            const data = JSON.parse(jsonStr);
+            if (data.message && typeof data.message === "string") {
+              content += data.message;
+            }
+          }
+        } catch (e) {
+          this.log("warn", "Failed to parse SSE data", {
+            line: trimmedLine,
+            error: e.message,
+          });
+        }
+      }
+    }
+
+    return content;
+  }
+
+  // 通用JSON响应
+  static jsonResponse(data: unknown, status = 200): Response {
+    this.log("info", "Creating JSON response", { status });
+    return new Response(JSON.stringify(data), {
+      status,
+      headers: { "Content-Type": "application/json" },
+    });
+  }
+}
+
+export function streamResponse(body: ReadableStream): Response {
+  return new Response(body, {
+    status: 200,
+    headers: {
+      "Content-Type": "text/event-stream",
+      Connection: "keep-alive",
+      "Cache-Control": "no-cache",
+    },
+  });
+}
+
+export function unauthorizedResponse(message: string, status = 401): Response {
+  return new Response(JSON.stringify({ error: message }), {
+    status,
+    headers: {
+      "Content-Type": "application/json",
+      "WWW-Authenticate": "Bearer",
+    },
+  });
+}
+
+export function errorResponse(message: string, status = 500): Response {
+  return ResponseBuilder.jsonResponse({ error: message }, status);
+}

router.ts

@@ -0,0 +1,28 @@
+// router.ts
+import { handleMeow, handleModels, handleChatCompletions } from "./handlers.ts";
+import { errorResponse } from "./response.ts";
+
+
+export async function router(req: Request): Promise<Response> {
+  const { method } = req;
+  const url = new URL(req.url);
+  const pathname = url.pathname;
+  
+  const routes = [
+    { method: "GET", path: "/v1/models", handler: handleModels },
+    { method: "POST", path: "/v1/chat/completions", handler: handleChatCompletions },
+    { method: "GET", path: "/", handler: handleMeow },
+  ];
+  
+  const route = routes.find(r => r.method === method && r.path === pathname);
+  
+  if (route) {
+    try {
+      return await route.handler(req);
+    } catch (error) {
+      return errorResponse(`处理请求时发生错误: ${error.message}`, 500);
+    }
+  }
+  
+  return errorResponse("未找到路由", 404);
+}

types.ts

@@ -0,0 +1,24 @@
+export interface ChatMessage {
+    role: "user" | "assistant" | "system" | string;
+    content: string;
+  }
+  
+  export interface ChatCompletionRequest {
+    model: string;
+    messages: ChatMessage[];
+    stream?: boolean;
+  }
+  
+  export interface ModelInfo {
+    id: string;
+    object: string;
+    created: number;
+    owned_by: string;
+  }
+  
+  export interface ApiResponse<T = unknown> {
+    data?: T;
+    error?: string;
+    object?: string;
+  }
+  

utils.ts

@@ -0,0 +1,31 @@
+const getBaseUrl = (): string => {
+    return Deno.env.get("BASE_URL") || "https://duckduckgo.com";
+};
+
+export const CONFIG = {
+  PORT: 8000,
+  DDG_STATUS_URL: `${getBaseUrl()}/duckchat/v1/status`,
+  DDG_CHAT_URL: `${getBaseUrl()}/duckchat/v1/chat`,
+  MODELS: [
+    "gpt-4o-mini",
+    "meta-llama/Llama-4-Scout-17B-16E-Instruct",
+    "claude-3-5-haiku-latest",
+    "o4-mini",
+    "mistralai/Mistral-Small-24B-Instruct-2501",
+  ],
+};
+
+export const userAgent =
+  "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/132.0.0.0 Safari/537.36";
+
+export const getToken = (): string | null => {
+  return Deno.env.has("TOKEN") ? "Bearer " + Deno.env.get("TOKEN") : null;
+};
+
+export const getHash = (): string | undefined => {
+  return Deno.env.get("HASH");
+};
+
+export const setHash = (hash: string): void => {
+  return Deno.env.set("HASH", hash);
+};

vm.ts

@@ -0,0 +1,171 @@
+import { JSDOM } from "npm:jsdom";
+import { userAgent } from "./utils.ts";
+import crypto from "node:crypto";
+
+// 更详细的类型定义
+interface MockMeta {
+  readonly origin: string;
+  readonly stack: string;
+  readonly duration: number;
+}
+
+interface HashResults {
+  server_hashes: string[];
+  client_hashes: string[];
+  signals: Record<string, unknown>;
+  meta: Record<string, unknown>;
+}
+
+interface JSExecutionResult {
+  server_hashes?: string[];
+  client_hashes?: string[];
+  signals?: Record<string, unknown>;
+  meta?: Record<string, unknown>;
+}
+
+const mockMeta: MockMeta = {
+  origin: "https://duckduckgo.com",
+  stack: "",
+  duration: Math.floor(Math.random() * 100) + 1,
+} as const;
+
+class VqdHashGenerator {
+  private static extractIIFEJSDOM(jsCode: string): HashResults {
+    const results: HashResults = {
+      server_hashes: [],
+      client_hashes: [],
+      signals: {},
+      meta: {},
+    };
+
+    let dom: JSDOM | null = null;
+
+    try {
+      dom = new JSDOM(
+        `<!DOCTYPE html><html><head></head><body></body></html>`,
+        {
+          url: "https://duckduckgo.com",
+          referrer: "https://duckduckgo.com",
+          pretendToBeVisual: true,
+          resources: "usable",
+        }
+      );
+
+      const { window } = dom;
+
+      // 设置全局变量
+      globalThis.window = window;
+      globalThis.document = window.document;
+      // 创建自定义 navigator 对象
+      const customNavigator = {
+        userAgent: userAgent,
+        platform: "Win32",
+        language: "en-US",
+        languages: ["en-US", "en"],
+        cookieEnabled: true,
+        onLine: true,
+        hardwareConcurrency: 4,
+        maxTouchPoints: 0,
+        vendor: "Google Inc.",
+        vendorSub: "",
+        productSub: "20030107",
+        appName: "Netscape",
+        appVersion: userAgent,
+        product: "Gecko",
+      };
+      // 重新定义 window.navigator
+      Object.defineProperty(window, "navigator", {
+        value: customNavigator,
+        writable: true,
+        configurable: true,
+        enumerable: true,
+      });
+      // 设置 globalThis.navigator
+      Object.defineProperty(globalThis, "navigator", {
+        value: customNavigator,
+        writable: true,
+        configurable: true,
+        enumerable: true,
+      });
+      // 删除 webdriver 属性
+      delete (window.navigator as any).webdriver;
+
+      // 执行 JavaScript 代码
+      const result = window.eval(jsCode) as JSExecutionResult;
+
+      if (result && typeof result === "object") {
+        results.server_hashes = result.server_hashes || [];
+        results.client_hashes = result.client_hashes || [];
+        results.signals = result.signals || {};
+        results.meta = result.meta || {};
+      }
+    } catch (error) {
+      console.error("JSDOM execution failed:", error);
+      throw new Error(
+        `JSDOM执行失败: ${
+          error instanceof Error ? error.message : String(error)
+        }`
+      );
+    } finally {
+      // 清理资源
+      if (dom) {
+        dom.window.close();
+      }
+      delete globalThis.window;
+      delete globalThis.document;
+      delete globalThis.navigator;
+    }
+
+    return results;
+  }
+
+  private static hashClientValues(mockClientHashes: string[]): string[] {
+    return mockClientHashes.map((value: string): string => {
+      const hash = crypto.createHash("sha256");
+      hash.update(value, "utf8");
+      return hash.digest("base64");
+    });
+  }
+
+  static generate(vqdHashRequest: string): string {
+    if (!vqdHashRequest || typeof vqdHashRequest !== "string") {
+      throw new Error("VQD Hash 请求参数无效");
+    }
+
+    try {
+      // 解码 base64
+      const jsCode = atob(vqdHashRequest);
+
+      // 提取和处理 hash
+      const hash = this.extractIIFEJSDOM(jsCode);
+
+      // 处理客户端 hash
+      hash.client_hashes = this.hashClientValues(hash.client_hashes);
+
+      // 合并 meta 数据
+      hash.meta = {
+        ...hash.meta,
+        ...mockMeta,
+      };
+
+      // 返回编码后的结果
+      return btoa(JSON.stringify(hash));
+    } catch (error) {
+      console.error("generateVqdHash 执行失败:", error);
+      throw new Error(
+        `VQD Hash 生成失败: ${
+          error instanceof Error ? error.message : String(error)
+        }`
+      );
+    }
+  }
+}
+
+// 导出函数版本以保持向后兼容
+export function generateVqdHash(vqdHashRequest: string): string {
+  return VqdHashGenerator.generate(vqdHashRequest);
+}
+
+// 导出类版本
+export { VqdHashGenerator };
+export type { HashResults, MockMeta, JSExecutionResult };