new file: .gitignore

new file: Dockerfile
modified: README.md
new file: package.json
new file: prompts/fix_json.txt
new file: prompts/function_call.txt
new file: server.js

.gitignore

@@ -0,0 +1,4 @@
+node_modules
+errors
+.env
+package-lock.json

Dockerfile

@@ -0,0 +1,32 @@
+# Use a lightweight Node.js base image
+FROM node:22-alpine
+
+# Create app directory
+WORKDIR /app
+
+# Install dependencies first (better layer caching)
+COPY package.json package-lock.json* yarn.lock* pnpm-lock.yaml* ./
+RUN npm ci --only=production || npm install --production
+
+# Copy source
+COPY . .
+
+# Copy prompts
+COPY prompts ./prompts
+
+# Create errors directory
+RUN mkdir -p errors
+
+# Set environment defaults
+ENV PORT=3000
+# ENV DEBUG=false
+# ENV OPENAI_BASE_URLS=https://api.openai.com,...
+# ENV OPENAI_KEYS=sk-xxx,...
+# ENV MODELS=gpt5,...
+# ENV DEFAULT_MODEL=gpt5
+
+# Expose server port
+EXPOSE ${PORT:-3000}
+
+# Start the server
+CMD ["node", "server.js"]

README.md

@@ -5,6 +5,7 @@ colorFrom: indigo
 colorTo: red
 sdk: docker
 pinned: false
+app-port: 3000
 ---
 
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

package.json

@@ -0,0 +1,14 @@
+{
+  "name": "chat2code",
+  "version": "1.0.0",
+  "type": "module",
+  "main": "server.js",
+  "scripts": {
+    "start": "DEBUG=true OPENAI_BASE_URLS=http://gptload.maomaotou.hidns.co:3001/proxy/dhcoder OPENAI_KEYS=sk-DsfX5Q3gNVhkKj0I_b2xtzMnMHmnoWjMDuDvI2mIMBKrlVPN MODELS=gpt-4.1-dhcoder DEFAULT_MODEL=gpt-4.1-dhcoder node server.js",
+    "dev": "NODE_ENV=development node server.js"
+  },
+  "dependencies": {
+    "@anthropic-ai/tokenizer": "^0.0.4",
+    "express": "^4.19.2"
+  }
+}

prompts/fix_json.txt

@@ -0,0 +1,4 @@
+The following is the content of a json text, but due to an error in the transmission process, it can no longer be successfully resolved to a json object, please try to fix it and wrap the repaired content in '<Json></Json>' tag:
+```
+<$JSON$>
+```

prompts/function_call.txt

@@ -0,0 +1,36 @@
+You will play as a code assistant, and the following text is for you:
+```system_prompt
+<$SystemPrompt$>
+```
+
+To help you solve problems better, you can use the following tools:
+```json
+<$Tools$>
+```
+Now, think about how the assistant should answer according to the following dialogue in json, and give your answer in json form as well:
+```
+<$Messages$>
+```
+Your answer should be formatted like this(don't forget the '<AnswerInJson>' tag):
+```
+<AnswerInJson>
+{
+  "role": "assistant",
+  "content": [
+    {
+      "type": "text",
+      "text": "..."
+    },
+    {
+      "type": "tool_use",
+      "name": "tool's name",
+      "input": {
+        "arg1's name": "arg1's value",
+        "arg2's name": "arg2's value",
+        ...
+      }
+    }
+  ]
+}
+</AnswerInJson>
+```

server.js

@@ -0,0 +1,304 @@
+import express from 'express';
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import crypto from 'crypto';
+import { countTokens } from '@anthropic-ai/tokenizer';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const env = process.env;
+const DEBUG = env.DEBUG === 'true';
+const modelMap = parseModelMap();
+const defaultModel = env.DEFAULT_MODEL || Object.keys(modelMap)[0];
+const responseCache = {};
+
+const FUNCTION_CALL_TPL = readPrompt('function_call');
+const FIX_JSON_TPL = readPrompt('fix_json');
+
+const app = express();
+app.use(express.json({ limit: '10mb' }));
+
+const jsonOk = (res, data, status = 200) => res.status(status).json(data);
+const jsonError = (res, status, message) => jsonOk(res, { error: { code: status, message } }, status);
+const getAuthHeader = (req) => req.get('authorization') || req.get('Authorization');
+const uuidHex = (len) => crypto.randomBytes(len / 2).toString('hex');
+const md5 = (text) => crypto.createHash('md5').update(text).digest('hex');
+
+function parseModelMap()
+{
+    // MODELS=gpt5,...
+    const models = env.MODELS?.split(',') || [];
+    // OPENAI_BASE_URLS=https://api.openai.com,...
+    const baseUrls = env.OPENAI_BASE_URLS?.split(',') || [];
+    // OPENAI_KEYS=sk-xxx,...
+    const keys = env.OPENAI_KEYS?.split(',') || [];
+    if (models.length !== baseUrls.length || models.length !== keys.length)
+        throw new Error('MODELS, OPENAI_BASE_URLS, OPENAI_KEYS must have the same length');
+    const map = {};
+    for (let i = 0; i < models.length; i++)
+    {
+        map[models[i]] = { baseUrl: baseUrls[i], key: keys[i] };
+    }
+    return map;
+}
+
+function readPrompt(promptName)
+{
+    const p = path.join(__dirname, `prompts/${promptName}.txt`);
+    if (fs.existsSync(p)) return fs.readFileSync(p, 'utf-8');
+    throw new Error(`${promptName}.txt not found`);
+}
+
+async function safeText(res)
+{
+    try
+    {
+        return await res.text();
+    }
+    catch (_)
+    {
+        return 'Unknown error';
+    }
+}
+
+function extractSystemText(system)
+{
+    if (!system) return '';
+    if (Array.isArray(system)) {
+        return system
+            .filter((i) => i && i.type === 'text')
+            .map((i) => String(i.text ?? ''))
+            .join('\n');
+    }
+    if (typeof system === 'string') return system;
+    return '';
+}
+
+function serializeContentToText(content)
+{
+    if (typeof content === 'string') return content;
+    if (Array.isArray(content))
+    {
+        const parts = [];
+        for (const item of content)
+        {
+            if (!item || typeof item !== 'object') continue;
+            if (item.type === 'text') parts.push(String(item.text ?? ''));
+            else if (item.type === 'tool_use')
+            {
+                const name = String(item.name ?? '');
+                const input = JSON.stringify(item.input ?? {});
+                parts.push(`[tool_use:${name}] ${input}`);
+            }
+            else if (item.type === 'tool_result')
+            {
+                const rtext = Array.isArray(item.content) ? item.content.map((c) => (c?.type === 'text' ? String(c.text ?? '') : '')).join('\n') : String(item.text ?? '');
+                parts.push(`[tool_result] ${rtext}`);
+            }
+        }
+        return parts.join('\n');
+    }
+    if (content && typeof content === 'object' && 'text' in content) return String(content.text ?? '');
+    return '';
+}
+
+function messagesToText(messages)
+{
+    if (!Array.isArray(messages)) return '';
+    return messages.map((m) =>
+    {
+        const role = String(m?.role ?? 'user');
+        const contentText = serializeContentToText(m?.content);
+        return `role:${role}\n${contentText}`;
+    }).join('\n---\n');
+}
+
+function countAnthropicTokensLocal(messages, system)
+{
+    try
+    {
+        const systemText = extractSystemText(system);
+        const messagesText = messagesToText(messages);
+        const full = [systemText, messagesText].filter(Boolean).join('\n---\n');
+        const n = countTokens(full);
+        return typeof n === 'number' && isFinite(n) ? n : 0;
+    }
+    catch (_)
+    {
+        return 0;
+    }
+}
+
+function getNowTimeText()
+{
+    const now = new Date();
+    const yyyy = now.getFullYear();
+    const mm = String(now.getMonth() + 1).padStart(2, '0');
+    const dd = String(now.getDate()).padStart(2, '0');
+    const HH = String(now.getHours()).padStart(2, '0');
+    const MM = String(now.getMinutes()).padStart(2, '0');
+    const SS = String(now.getSeconds()).padStart(2, '0');
+    return `${yyyy}-${mm}-${dd}-${HH}:${MM}:${SS}`;
+}
+
+async function tryToFixJson(auth, jsonText)
+{
+    const jsonResp = await fetch(`${modelMap[defaultModel].baseUrl}/v1/chat/completions`, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            Authorization: auth,
+        },
+        body: JSON.stringify({
+            model: defaultModel,
+            messages: [{ role: 'user', content: FIX_JSON_TPL.replace('<$JSON$>', jsonText) }],
+            stream: false,
+        }),
+    });
+    if (!jsonResp.ok) return null;
+    const openai = await jsonResp.json();
+    let content = String(openai?.choices?.[0]?.message?.content ?? '');
+    content = content.replace(/<Json>[\s\S]*?<\/Json>/g, '').replace(/\\<Json\\>/g, '<Json>').replace(/\\<\/Json\\>/g, '</Json>');
+    const match = content.match(/<Json>([\s\S]*?)<\/Json>/);
+    if (!match) return null;
+    try
+    {
+        console.log('fix json');
+        return JSON.parse(match[1].trim());
+    }
+    catch (e)
+    {
+        console.log('but failed');
+        return null;
+    }
+}
+
+app.post('/v1/messages', async (req, res) =>
+{
+    if(!modelMap[req.body.model]) req.body.model = defaultModel;
+    const auth = getAuthHeader(req);
+    if (!auth) return jsonError(res, 401, 'missing authorization header');
+    const nowTimeText = getNowTimeText();
+    const body = req.body || {};
+    let logText = `[Request]\nUrl: ${req.url}\nMethod: ${req.method}\nBody: ${JSON.stringify(body)}\n\n`;
+    const systemText = extractSystemText(body?.system);
+    const toolsStr = JSON.stringify(body?.tools ?? []);
+    const messagesStr = JSON.stringify(body?.messages ?? []);
+    const fcPrompt = FUNCTION_CALL_TPL.replaceAll('<$SystemPrompt$>', systemText)
+                            .replaceAll('<$Tools$>', toolsStr)
+                            .replaceAll('<$Messages$>', messagesStr);
+    const openaiReq = {
+        model: body?.model,
+        messages: [{ role: 'user', content: fcPrompt }],
+        stream: false,
+        max_tokens: body?.max_tokens,
+        temperature: body?.temperature,
+    };
+    try
+    {
+        let answerTag = `${md5(JSON.stringify(openaiReq.messages))}-${openaiReq.model}`;
+        if (responseCache[answerTag])
+        {
+            let resp = responseCache[answerTag];
+            resp.id = uuidHex(32);
+            resp.usage.input_tokens = 0;
+            resp.usage.output_tokens = 0;
+            resp.usage.cache_read_input_tokens = 0;
+            return jsonOk(res, resp);
+        }
+        const chatResp = await fetch(`${modelMap[body.model].baseUrl}/v1/chat/completions`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: auth,
+            },
+            body: JSON.stringify(openaiReq),
+        });
+        if (!chatResp.ok)
+        {
+            const message = await safeText(chatResp);
+            logText += `[Response]\nStatus: ${chatResp.status}\nBody: ${message}\n\n`;
+            if(DEBUG) fs.writeFileSync(`errors/${nowTimeText}.txt`, logText, 'utf-8');
+            return jsonError(res, chatResp.status, message);
+        }
+        const openai = await chatResp.json();
+        logText += `[Response]\nStatus: ${chatResp.status}\nBody: ${JSON.stringify(openai)}\n\n`;
+        let content = String(openai?.choices?.[0]?.message?.content ?? '');
+        content = content.replace(/<think>[\s\S]*<\/think>/g, '').replace(/\\<AnswerInJson\\>/g, '<AnswerInJson>').replace(/\\<\/AnswerInJson\\>/g, '</AnswerInJson>');
+        const match = content.match(/<AnswerInJson>([\s\S]*)<\/AnswerInJson>/);
+        if (!match)
+        {
+            logText += `[ParseFailed]\nParse failed : ${content}\n\n`;
+            if(DEBUG) fs.writeFileSync(`errors/${nowTimeText}.txt`, logText, 'utf-8');
+            return jsonError(res, 500, `parse failed : ${content}`);
+        }
+        let raw;
+        let answerObj;
+        try
+        {
+            raw = match[1].trim().replace(/&quot;/, '"').replace(/\\_/, '_');
+            let headIndex = raw.indexOf('{');
+            if (headIndex > 0) raw = raw.substring(headIndex);
+            let tailIndex = raw.lastIndexOf('}');
+            if (tailIndex > 0) raw = raw.substring(0, tailIndex + 1);
+            answerObj = JSON.parse(raw);
+        }
+        catch (e)
+        {
+            answerObj = await tryToFixJson(raw);
+            if(!answerObj)
+            {
+                logText += `[JsonFailed]\nRaw:\n${raw}\nError:\n${e.message}\n`;
+                if(DEBUG) fs.writeFileSync(`errors/${nowTimeText}.txt`, logText, 'utf-8');
+                return jsonError(res, 500, `parse failed : ${content}`);
+            }
+        }
+        if (Array.isArray(answerObj?.content))
+        {
+            for (const item of answerObj.content)
+            {
+                if (item && item.type === 'tool_use') item.id = `call_${uuidHex(24)}`;
+            }
+        }
+        const inputTokens = countAnthropicTokensLocal(body?.model, body?.messages, body?.system);
+        const outputTokens = (() => {
+            try
+            {
+                const n = countTokens(content);
+                return typeof n === 'number' && isFinite(n) ? n : 0;
+            }
+            catch (_)
+            {
+                return 0;
+            }
+        })();
+        const response = {
+            id: uuidHex(32),
+            type: 'message',
+            role: 'assistant',
+            content: answerObj.content,
+            model: body?.model,
+            stop_reason:
+                Array.isArray(answerObj?.content) && answerObj.content.find((i) => i?.type === 'tool_use')
+                    ? 'tool_use'
+                    : 'end_turn',
+            usage: {
+                input_tokens: inputTokens,
+                output_tokens: outputTokens,
+                cache_read_input_tokens: 0,
+            },
+        };
+        responseCache[answerTag] = response;
+        return jsonOk(res, response);
+    }
+    catch (e)
+    {
+        return jsonError(res, 500, String(e?.message || e));
+    }
+});
+
+const port = Number(env.PORT || 3000);
+app.listen(port, () => {
+    console.log(`Server listening on http://localhost:${port}`);
+});