Rename main.ts to adapter.ts

adapter.ts

@@ -0,0 +1,255 @@
+// deno run --allow-net --allow-env adapter.ts
+
+import { serve } from "https://deno.land/std@0.203.0/http/server.ts";
+
+// --- Configuration from Environment Variables (Safer for deployment) ---
+
+function getKeysFromEnv(envVarName: string): Set<string> {
+  const keysString = Deno.env.get(envVarName);
+  if (!keysString) {
+    console.warn(`Environment variable ${envVarName} is not set.`);
+    return new Set();
+  }
+  // Split by comma and trim whitespace, filter out empty strings
+  return new Set(keysString.split(',').map(k => k.trim()).filter(Boolean));
+}
+
+// Client keys will be read from Hugging Face Secrets
+const CLIENT_API_KEYS = getKeysFromEnv("CLIENT_KEYS"); 
+
+// CodeGeeX tokens will also be read from Hugging Face Secrets
+const codegeeXTokensRaw = Array.from(getKeysFromEnv("CODEGEEX_KEYS"));
+
+const CODEGEEX_TOKENS: {
+  token: string;
+  isValid: boolean;
+  lastUsed: number;
+  errorCount: number;
+}[] = codegeeXTokensRaw.map(token => ({
+    token: token,
+    isValid: true,
+    lastUsed: 0,
+    errorCount: 0
+}));
+
+
+const MAX_ERROR_COUNT = 3;
+const ERROR_COOLDOWN = 300 * 1000; // ms
+
+// --- Utilities ---
+function now(): number {
+  return Date.now();
+}
+
+function rotateToken(): typeof CODEGEEX_TOKENS[0] | null {
+  if (CODEGEEX_TOKENS.length === 0) {
+      console.error("CODEGEEX_TOKENS array is empty. Check your CODEGEEX_KEYS secret.");
+      return null;
+  }
+    
+  const available = CODEGEEX_TOKENS.filter(t => {
+    if (!t.isValid) return false;
+    if (t.errorCount >= MAX_ERROR_COUNT && now() - t.lastUsed < ERROR_COOLDOWN) return false;
+    return true;
+  });
+  if (available.length === 0) return null;
+
+  // reset cooled-down tokens
+  for (const t of available) {
+    if (t.errorCount >= MAX_ERROR_COUNT && now() - t.lastUsed >= ERROR_COOLDOWN) {
+      t.errorCount = 0;
+    }
+  }
+
+  // pick the one least recently used, then lowest errorCount
+  available.sort((a, b) => a.lastUsed - b.lastUsed || a.errorCount - b.errorCount);
+  const tok = available[0];
+  tok.lastUsed = now();
+  return tok;
+}
+
+// This function translates the OpenAI format to CodeGeeX format
+function convertToCodeGeeXPayload(params: { model: string; messages: any[] }) {
+    // CodeGeeX seems to use the last message's content as the main prompt.
+    // The history part is more complex, here we simplify it.
+    const lastMessage = params.messages.slice(-1)[0];
+    const history = params.messages.slice(0, -1)
+        .filter(msg => msg.role === 'user' || msg.role === 'assistant')
+        .map(msg => ({
+            role: msg.role,
+            content: msg.content
+        }));
+
+    return {
+        user_role: 0, // This seems to be a fixed value
+        ide: "HuggingFace", // Let's identify the source
+        prompt: lastMessage?.content || "",
+        history: history, // Passing a simplified history
+        model: params.model,
+    };
+}
+
+
+async function proxyChat(req: Request, params: { stream: boolean; model: string; messages: any[] }) {
+  const tokenObj = rotateToken();
+  if (!tokenObj) {
+    return new Response(JSON.stringify({ error: { message: "No valid CodeGeeX tokens available", type: "server_error" } }), { status: 503, headers: { "Content-Type": "application/json" }});
+  }
+
+  const payload = convertToCodeGeeXPayload(params);
+
+  try {
+    const response = await fetch("https://codegeex.cn/prod/code/chatCodeSseV3/chat", {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Accept": "text/event-stream",
+        "code-token": tokenObj.token,
+      },
+      body: JSON.stringify(payload),
+    });
+
+    if (!response.ok) {
+      console.error(`Upstream error from CodeGeeX: ${response.status}`);
+      if (response.status === 401 || response.status === 403) {
+        tokenObj.isValid = false;
+        console.warn(`Token ${tokenObj.token.substring(0, 15)}... marked as invalid due to 401/403 error.`);
+      } else {
+        tokenObj.errorCount++;
+        console.warn(`Token ${tokenObj.token.substring(0, 15)}... error count increased to ${tokenObj.errorCount}.`);
+      }
+      const errorBody = await response.text();
+      return new Response(JSON.stringify({ error: { message: `Upstream error ${response.status}: ${errorBody}`, type: "upstream_error" } }), { status: 502, headers: { "Content-Type": "application/json" }});
+    }
+
+    // For stream, we must transform the raw CodeGeeX SSE to OpenAI format
+    if (params.stream) {
+        const { readable, writable } = new TransformStream();
+        const writer = writable.getWriter();
+        const encoder = new TextEncoder();
+
+        // This function processes the stream from CodeGeeX and sends OpenAI compatible chunks
+        (async () => {
+            const reader = response.body?.getReader();
+            if (!reader) {
+                await writer.close();
+                return;
+            }
+            const decoder = new TextDecoder();
+            const completionId = `chatcmpl-${crypto.randomUUID()}`;
+            const creationTime = Math.floor(now() / 1000);
+
+            try {
+                while(true) {
+                    const { done, value } = await reader.read();
+                    if (done) break;
+
+                    const chunkText = decoder.decode(value);
+                    // A simple transformation: assume the raw chunk is the content delta
+                    const openAIChunk = {
+                        id: completionId,
+                        object: "chat.completion.chunk",
+                        created: creationTime,
+                        model: params.model,
+                        choices: [{ delta: { content: chunkText }, index: 0, finish_reason: null }]
+                    };
+                    await writer.write(encoder.encode(`data: ${JSON.stringify(openAIChunk)}\n\n`));
+                }
+                // Send the final DONE chunk
+                await writer.write(encoder.encode(`data: [DONE]\n\n`));
+            } catch (e) {
+                console.error("Error while transforming stream:", e);
+            } finally {
+                await writer.close();
+            }
+        })();
+        
+        return new Response(readable, {
+            status: 200,
+            headers: { "Content-Type": "text/event-stream", "Cache-Control": "no-cache", "Connection": "keep-alive" },
+        });
+    } else {
+      // accumulate and return JSON
+      const text = await response.text();
+      return new Response(JSON.stringify({
+        id: `chatcmpl-${crypto.randomUUID()}`,
+        object: "chat.completion",
+        created: Math.floor(now() / 1000),
+        model: params.model,
+        choices: [{ message: { role: "assistant", content: text }, index: 0, finish_reason: "stop" }],
+        usage: { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 } // Placeholder usage
+      }), {
+        status: 200,
+        headers: { "Content-Type": "application/json" },
+      });
+    }
+  } catch (err) {
+    tokenObj.errorCount++;
+    console.error("Fetch to CodeGeeX failed:", err);
+    return new Response(JSON.stringify({ error: { message: err.message, type: "server_error" } }), { status: 500, headers: { "Content-Type": "application/json" }});
+  }
+}
+
+// --- Main Handler ---
+async function handler(req: Request): Promise<Response> {
+  const url = new URL(req.url);
+  console.log(`Received request: ${req.method} ${url.pathname}`);
+
+  // CORS preflight request handler for web clients
+  if (req.method === 'OPTIONS') {
+    return new Response(null, {
+      status: 204,
+      headers: {
+        'Access-Control-Allow-Origin': '*',
+        'Access-Control-Allow-Methods': 'GET, POST, OPTIONS',
+        'Access-Control-Allow-Headers': 'Content-Type, Authorization',
+      },
+    });
+  }
+  
+  // Authentication middleware
+  const auth = req.headers.get("Authorization")?.replace(/^Bearer\s+/, "");
+  if (CLIENT_API_KEYS.size === 0) {
+    console.error("Server misconfigured: CLIENT_KEYS secret is not set or empty.");
+    return new Response(JSON.stringify({ error: { message: "Server misconfigured: no client keys", type: "server_error" }}), { status: 503, headers: { "Content-Type": "application/json" }});
+  }
+  if (!auth || !CLIENT_API_KEYS.has(auth)) {
+    return new Response(JSON.stringify({ error: { message: "Invalid or missing API key", type: "auth_error" }}), {
+      status: 401,
+      headers: { "WWW-Authenticate": "Bearer", "Content-Type": "application/json" },
+    });
+  }
+
+  // GET /v1/models
+  if (url.pathname === "/v1/models" && req.method === "GET") {
+    const modelData = [
+      { id: "codegeex-4", object: "model", created: Math.floor(now() / 1000), owned_by: "codegeex" },
+      { id: "codegeex-pro", object: "model", created: Math.floor(now() / 1000), owned_by: "codegeex" }
+    ];
+    return new Response(JSON.stringify({ object: "list", data: modelData }), {
+      headers: { "Content-Type": "application/json" },
+    });
+  }
+
+  // POST /v1/chat/completions
+  if (url.pathname === "/v1/chat/completions" && req.method === "POST") {
+    try {
+        const body = await req.json();
+        const { model, messages, stream = true } = body;
+        if (!model || !Array.isArray(messages) || messages.length === 0) {
+          return new Response(JSON.stringify({ error: { message: "Bad Request: 'model' and 'messages' are required.", type: "invalid_request_error" } }), { status: 400, headers: { "Content-Type": "application/json" }});
+        }
+        return proxyChat(req, { model, messages, stream });
+    } catch (e) {
+        return new Response(JSON.stringify({ error: { message: "Invalid JSON body.", type: "invalid_request_error" } }), { status: 400, headers: { "Content-Type": "application/json" }});
+    }
+  }
+
+  // Not found
+  return new Response(JSON.stringify({ error: "Not Found" }), { status: 404, headers: { "Content-Type": "application/json" }});
+}
+
+// --- Start Server ---
+const PORT = 7860; // Use the standard port for Hugging Face Spaces
+console.log(`Starting Deno CodeGeeX Adapter on http://0.0.0.0:${PORT}`);
+serve(handler, { port: PORT });

main.ts

@@ -1,171 +0,0 @@
-// deno run --allow-net --allow-env adapter.ts
-
-import { serve } from "https://deno.land/std@0.203.0/http/server.ts";
-
-// --- Hardcoded API Keys ---
-const CLIENT_API_KEYS = new Set([
-  "sk-client-1234567890abcdef",
-  // add more client keys here
-]);
-
-const CODEGEEX_TOKENS: {
-  token: string;
-  isValid: boolean;
-  lastUsed: number;
-  errorCount: number;
-}[] = [
-  { token: "cgx-token-AAAA", isValid: true, lastUsed: 0, errorCount: 0 },
-  { token: "cgx-token-BBBB", isValid: true, lastUsed: 0, errorCount: 0 },
-  // add more CodeGeeX tokens here
-];
-
-const MAX_ERROR_COUNT = 3;
-const ERROR_COOLDOWN = 300 * 1000; // ms
-
-// --- Utilities ---
-function now(): number {
-  return Date.now();
-}
-
-function rotateToken(): typeof CODEGEEX_TOKENS[0] | null {
-  const available = CODEGEEX_TOKENS.filter(t => {
-    if (!t.isValid) return false;
-    if (t.errorCount >= MAX_ERROR_COUNT && now() - t.lastUsed < ERROR_COOLDOWN) return false;
-    return true;
-  });
-  if (available.length === 0) return null;
-
-  // reset cooled-down tokens
-  for (const t of available) {
-    if (t.errorCount >= MAX_ERROR_COUNT && now() - t.lastUsed >= ERROR_COOLDOWN) {
-      t.errorCount = 0;
-    }
-  }
-
-  // pick the one least recently used, then lowest errorCount
-  available.sort((a, b) => a.lastUsed - b.lastUsed || a.errorCount - b.errorCount);
-  const tok = available[0];
-  tok.lastUsed = now();
-  return tok;
-}
-
-async function proxyChat(req: Request, params: { stream: boolean; model: string; messages: any[] }) {
-  const tokenObj = rotateToken();
-  if (!tokenObj) {
-    return new Response(JSON.stringify({ error: "No valid CodeGeeX tokens available" }), { status: 503 });
-  }
-
-  const payload = {
-    user_role: 0,
-    ide: "Deno",
-    prompt: params.messages.slice(-1)[0]?.content || "",
-    history: [], // Simplified: not preserving history in this example
-    model: params.model,
-  };
-
-  try {
-    const response = await fetch("https://codegeex.cn/prod/code/chatCodeSseV3/chat", {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        "Accept": "text/event-stream",
-        "code-token": tokenObj.token,
-      },
-      body: JSON.stringify(payload),
-    });
-    if (!response.ok) {
-      if (response.status === 401 || response.status === 403) {
-        tokenObj.isValid = false;
-      } else {
-        tokenObj.errorCount++;
-      }
-      return new Response(JSON.stringify({ error: `Upstream error ${response.status}` }), { status: 502 });
-    }
-
-    if (params.stream) {
-      // proxy SSE
-      return new Response(response.body, {
-        status: 200,
-        headers: {
-          "Content-Type": "text/event-stream",
-          "Cache-Control": "no-cache",
-          Connection: "keep-alive",
-        },
-      });
-    } else {
-      // accumulate and return JSON
-      const text = await response.text();
-      return new Response(JSON.stringify({
-        id: `chatcmpl-${crypto.randomUUID()}`,
-        object: "chat.completion",
-        created: Math.floor(now() / 1000),
-        model: params.model,
-        choices: [{ message: { role: "assistant", content: text }, index: 0, finish_reason: "stop" }],
-      }), {
-        status: 200,
-        headers: { "Content-Type": "application/json" },
-      });
-    }
-  } catch (err) {
-    tokenObj.errorCount++;
-    return new Response(JSON.stringify({ error: err.message }), { status: 500 });
-  }
-}
-
-// --- Handlers ---
-async function handler(req: Request): Promise<Response> {
-  const url = new URL(req.url);
-
-  // /debug?enable=true|false
-  if (url.pathname === "/debug" && req.method === "GET") {
-    const en = url.searchParams.get("enable");
-    if (en !== null) {
-      Deno.env.set("DEBUG_MODE", en);
-    }
-    return new Response(JSON.stringify({ debug_mode: Deno.env.get("DEBUG_MODE") === "true" }), {
-      headers: { "Content-Type": "application/json" },
-    });
-  }
-
-  // Authentication middleware
-  const auth = req.headers.get("Authorization")?.replace(/^Bearer\s+/, "");
-  if (!CLIENT_API_KEYS.size) {
-    return new Response(JSON.stringify({ error: "Server misconfigured: no client keys" }), { status: 503 });
-  }
-  if (!auth || !CLIENT_API_KEYS.has(auth)) {
-    return new Response(JSON.stringify({ error: "Invalid or missing API key" }), {
-      status: 401,
-      headers: { "WWW-Authenticate": "Bearer" },
-    });
-  }
-
-  // GET /v1/models and GET /models
-  if ((url.pathname === "/v1/models" || url.pathname === "/models") && req.method === "GET") {
-    const data = CODEGEEX_TOKENS.map((_, i) => ({
-      id: [`claude-3-7-sonnet`, `claude-sonnet-4`][i % 2],
-      owned_by: "anthropic",
-      created: Math.floor(now() / 1000),
-      object: "model",
-    }));
-    return new Response(JSON.stringify({ object: "list", data }), {
-      headers: { "Content-Type": "application/json" },
-    });
-  }
-
-  // POST /v1/chat/completions
-  if (url.pathname === "/v1/chat/completions" && req.method === "POST") {
-    const body = await req.json();
-    const { model, messages, stream = true } = body;
-    if (!model || !Array.isArray(messages)) {
-      return new Response(JSON.stringify({ error: "Bad Request" }), { status: 400 });
-    }
-    return proxyChat(req, { model, messages, stream });
-  }
-
-  // Not found
-  return new Response(JSON.stringify({ error: "Not Found" }), { status: 404 });
-}
-
-// --- Start Server ---
-console.log("Starting Deno CodeGeeX Adapter on http://0.0.0.0:8000");
-serve(handler, { port: 8000 });