add

Dockerfile

@@ -0,0 +1,13 @@
+FROM node:lts-alpine
+
+WORKDIR /app
+
+COPY package*.json ./
+
+RUN npm install
+
+COPY . .
+ENV PORT 7860
+EXPOSE 7860
+
+CMD ["npm", "start"]

docker-compose.yml

@@ -0,0 +1,9 @@
+services:
+  app:
+    image: my-chat-api
+    build: .
+    ports:
+      - "7860:7860"
+    environment:
+      NODE_ENV: production
+    restart: unless-stopped  # 自动重启

index.js

@@ -0,0 +1,396 @@
+import express from 'express';
+import WebSocket from 'ws';
+import { v4 as uuidv4 } from 'uuid';
+import { randomBytes } from 'crypto';
+import cors from 'cors';
+import dotenv from 'dotenv';
+
+// 配置加载
+dotenv.config();
+
+// 配置常量
+const CONFIG = {
+    API: {
+        BASE_URL: "wss://api.inkeep.com/graphql",
+        API_KEY: process.env.API_KEY || "sk-123456",
+    },
+    MODELS: {
+        'claude-3-5-sonnet-20241022': 'claude-3-5-sonnet-20241022',
+    },
+    SERVER: {
+        PORT: process.env.PORT || 3000,
+        BODY_LIMIT: '5mb'
+    },
+    DEFAULT_HEADERS: {
+        'Host': 'api.inkeep.com',
+        'Connection': 'Upgrade',
+        'Pragma': 'no-cache',
+        'Cache-Control': 'no-cache',
+        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/133.0.0.0 Safari/537.36',
+        'Upgrade': 'websocket',
+        'Origin': 'https://docs.anthropic.com',
+        'Sec-WebSocket-Version': '13',
+        'Accept-Encoding': 'gzip, deflate, br, zstd',
+        'Accept-Language': 'zh-CN,zh;q=0.9',
+        'Sec-WebSocket-Extensions': 'permessage-deflate; client_max_window_bits',
+        'Sec-WebSocket-Protocol': 'graphql-transport-ws'
+    }
+};
+
+// AI API 客户端类
+class AiApiClient {
+    constructor(modelId) {
+        this.modelId = CONFIG.MODELS[modelId];
+        if (!this.modelId) {
+            throw new Error(`不支持的模型: ${modelId}`);
+        }
+    }
+
+    // 处理消息内容
+    processMessageContent(content) {
+        if (typeof content === 'string') return content;
+        if (Array.isArray(content)) {
+            return content
+                .filter(item => item.type === 'text')
+                .map(item => item.text)
+                .join('\n');
+        }
+        return typeof content === 'object' ? content.text || null : null;
+    }
+
+    // 转换消息格式
+    async transformMessages(request) {
+        let systemMessageList = [];
+        let systemMergeMode = false;
+        let closedSystemMergeMode = false;
+
+        const contextMessages = await request.messages.reduce(async (accPromise, current) => {
+            const acc = await accPromise;
+            const currentContent = this.processMessageContent(current.content);
+
+            if (currentContent === null) return acc;
+
+            const currentMessageRole = current.role === "system" ? "USER" : current.role.toUpperCase();
+
+            // 系统消息处理逻辑
+            if (current.role === "system") {
+                if (!closedSystemMergeMode) {
+                    systemMergeMode = true;
+                    const lastSystemMessage = systemMessageList[systemMessageList.length - 1];
+
+                    if (!lastSystemMessage) {
+                        systemMessageList.push(currentContent);
+                    } else {
+                        systemMessageList[systemMessageList.length - 1] = `${lastSystemMessage}\n${currentContent}`;
+                    }
+                    return acc;
+                }
+            }
+
+            // 关闭系统消息合并模式
+            if (current.role !== "system" && systemMergeMode) {
+                systemMergeMode = false;
+                closedSystemMergeMode = true;
+            }
+
+            // 消息合并逻辑
+            const previousMessage = acc[acc.length - 1];
+            const newMessage = `${currentMessageRole}: ${currentContent}`;
+
+            if (!previousMessage || previousMessage.startsWith(currentMessageRole)) {
+                return previousMessage
+                    ? [...acc.slice(0, -1), `${previousMessage}\n${currentContent}`]
+                    : [...acc, newMessage];
+            }
+
+            return [...acc, newMessage];
+        }, Promise.resolve([]));
+
+        return {
+            contextMessages: contextMessages.join('\n'),
+            systemMessage: systemMessageList.join('\n')
+        };
+    }
+}
+
+// 响应处理类
+class ResponseHandler {
+    // 流式响应处理
+    static async handleStreamResponse(responseContent, model, res) {
+        res.setHeader('Content-Type', 'text/event-stream');
+        res.setHeader('Cache-Control', 'no-cache');
+        res.setHeader('Connection', 'keep-alive');
+
+        let index = 0;
+        while (index < responseContent.length) {
+            const chunkSize = Math.floor(Math.random() * (30 - 16)) + 15;
+            const chunk = responseContent.slice(index, index + chunkSize);
+
+            res.write(`data: ${JSON.stringify({
+                id: uuidv4(),
+                object: 'chat.completion.chunk',
+                created: Math.floor(Date.now() / 1000),
+                model: model,
+                choices: [{
+                    index: 0,
+                    delta: { content: chunk },
+                    finish_reason: null
+                }]
+            })}\n\n`);
+
+            index += chunkSize;
+            await new Promise(resolve => setTimeout(resolve, 50));
+        }
+
+        res.write('data: [DONE]\n\n');
+        res.end();
+    }
+
+    // 普通响应处理
+    static async handleNormalResponse(userMessage, responseContent, model, res) {
+        res.json({
+            id: uuidv4(),
+            object: "chat.completion",
+            created: Math.floor(Date.now() / 1000),
+            model: model,
+            choices: [{
+                index: 0,
+                message: {
+                    role: "assistant",
+                    content: responseContent
+                },
+                finish_reason: "stop"
+            }],
+            usage: {
+                prompt_tokens: userMessage.length,
+                completion_tokens: responseContent.length,
+                total_tokens: userMessage.length + responseContent.length
+            }
+        });
+    }
+}
+
+// WebSocket工具类
+class WebSocketUtils {
+    // 生成WebSocket密钥
+    static generateWebSocketKey() {
+        return randomBytes(16).toString('base64');
+    }
+
+    // 创建WebSocket客户端
+    static createWebSocketClient(requestPayload, onChunk) {
+        return new Promise((resolve, reject) => {
+            const websocketKey = this.generateWebSocketKey();
+            const ws = new WebSocket(CONFIG.API.BASE_URL, 'graphql-transport-ws', {
+                headers: {
+                    ...CONFIG.DEFAULT_HEADERS,
+                    'Sec-WebSocket-Key': websocketKey,
+                }
+            });
+
+            let lastContent = '';
+            let responseContent = '';
+            let isComplete = false;
+
+            ws.on('open', () => {
+                console.time('query');
+                console.log("WebSocket连接已打开");
+                const connectionInitMessage = {
+                    type: 'connection_init',
+                    payload: {
+                        headers: {
+                            Authorization: 'Bearer ee5b7c15ed3553cd6abc407340aad09ac7cb3b9f76d8613a'
+                        }
+                    }
+                };
+                ws.send(JSON.stringify(connectionInitMessage));
+            });
+
+            ws.on('message', async (data) => {
+                const message = data.toString();
+                const parsedMessage = JSON.parse(message);
+                console.log("收到消息：", message);
+
+                switch (parsedMessage.type) {
+                    case 'connection_ack':
+                        this.sendChatSubscription(ws, requestPayload);
+                        break;
+                    case 'next':
+                        try {
+                            const chatResult = parsedMessage.payload.data.newSessionChatResult;
+                            if (chatResult && chatResult.message) {
+                                const currentContent = chatResult.message.content || '';
+
+                                // 计算增量内容
+                                const delta = currentContent.slice(lastContent.length);
+                                lastContent = currentContent;
+                                responseContent = currentContent;
+
+                                if (delta && onChunk) {
+                                    const payload = {
+                                        id: uuidv4(),
+                                        object: 'chat.completion.chunk',
+                                        created: Math.floor(Date.now() / 1000),
+                                        model: requestPayload.modelId,
+                                        choices: [{
+                                            index: 0,
+                                            delta: { content: delta },
+                                            finish_reason: null
+                                        }]
+                                    };
+                                    onChunk(payload);
+                                }
+                            }
+                        } catch (e) {
+                            console.error('处理消息时出错:', e);
+                        }
+                        break;
+                    case 'complete':
+                        isComplete = true;
+                        ws.close();
+                        resolve(responseContent);
+                        break;
+                }
+            });
+            ws.on('error', (err) => {
+                console.error('WebSocket错误:', err);
+                reject(err);
+            });
+
+            ws.on('close', (code, reason) => {
+                console.log('请求完毕，关闭连接');
+                console.timeEnd('query');
+                if (!isComplete) {
+                    reject(new Error('WebSocket closed unexpectedly'));
+                }
+            });
+        });
+    }
+
+    // 发送聊天订阅
+    static sendChatSubscription(ws, requestPayload) {
+        const subscribeMessage = {
+            id: uuidv4(),
+            type: 'subscribe',
+            payload: {
+                variables: {
+                    messageInput: requestPayload.contextMessages,
+                    messageContext: null,
+                    organizationId: 'org_JfjtEvzbwOikUEUn',
+                    integrationId: 'clwtqz9sq001izszu8ms5g4om',
+                    chatMode: 'AUTO',
+                    context: requestPayload.systemMessage,
+                    messageAttributes: {},
+                    includeAIAnnotations: false,
+                    environment: 'production'
+                },
+                extensions: {},
+                operationName: 'OnNewSessionChatResult',
+                query: `subscription OnNewSessionChatResult($messageInput: String!, $messageContext: String, $organizationId: ID!, $integrationId: ID, $chatMode: ChatMode, $filters: ChatFiltersInput, $messageAttributes: JSON, $tags: [String!], $workflowId: String, $context: String, $guidance: String, $includeAIAnnotations: Boolean!, $environment: String) {
+                  newSessionChatResult(
+                      input: {messageInput: $messageInput, messageContext: $messageContext, organizationId: $organizationId, integrationId: $integrationId, chatMode: $chatMode, filters: $filters, messageAttributes: $messageAttributes, tags: $tags, workflowId: $workflowId, context: $context, guidance: $guidance, environment: $environment}
+                  ) {
+                      isEnd
+                      sessionId
+                      message {
+                          id
+                          content
+                      }
+                      __typename
+                  }
+              }`
+            }
+        };
+        console.log(JSON.stringify(subscribeMessage))
+
+        ws.send(JSON.stringify(subscribeMessage));
+    }
+
+    // 处理聊天响应
+    static async handleChatResponse(message) {
+        if (message.payload && message.payload.data) {
+            const chatResult = message.payload.data.newSessionChatResult;
+            if (chatResult && chatResult.isEnd == true && chatResult.message) {
+                return chatResult.message.content;
+            }
+        }
+        return null;
+    }
+}
+
+// 创建Express应用
+const app = express();
+
+// 中间件配置
+app.use(express.json({ limit: CONFIG.SERVER.BODY_LIMIT }));
+app.use(express.urlencoded({ extended: true, limit: CONFIG.SERVER.BODY_LIMIT }));
+app.use(cors({
+    origin: '*',
+    methods: ['GET', 'POST', 'OPTIONS'],
+    allowedHeaders: ['Content-Type', 'Authorization']
+}));
+
+// 获取模型列表路由
+app.get('/v1/models', (req, res) => {
+    res.json({
+        object: "list",
+        data: [{
+            id: "claude-3-5-sonnet-20241022",
+            object: "model",
+            created: Math.floor(Date.now() / 1000),
+            owned_by: "claude",
+        }]
+    });
+});
+
+// 聊天完成路由
+app.post('/v1/chat/completions', async (req, res) => {
+    try {
+        const { messages, model, stream } = req.body;
+        const authToken = req.headers.authorization?.replace('Bearer ', '');
+
+        if (authToken !== CONFIG.API.API_KEY) {
+            return res.status(401).json({ error: "Unauthorized" });
+        }
+
+        const apiClient = new AiApiClient(req.body.model);
+        const requestPayload = await apiClient.transformMessages(req.body);
+
+        const userMessage = messages.reverse().find(message => message.role === 'user')?.content;
+        if (!userMessage) {
+            return res.status(400).json({ error: "缺失用户消息" });
+        }
+
+        if (stream) {
+            res.setHeader('Content-Type', 'text/event-stream');
+            res.setHeader('Cache-Control', 'no-cache');
+            res.setHeader('Connection', 'keep-alive');
+
+            await WebSocketUtils.createWebSocketClient(
+                { ...requestPayload, modelId: model },
+                (chunk) => {
+                    res.write(`data: ${JSON.stringify(chunk)}\n\n`);
+                }
+            );
+
+            res.write('data: [DONE]\n\n');
+            res.end();
+        } else {
+            const responseContent = await WebSocketUtils.createWebSocketClient(requestPayload);
+            await ResponseHandler.handleNormalResponse(userMessage, responseContent, model, res);
+        }
+    } catch (error) {
+        console.error('处理请求时发生错误:', error);
+        res.status(500).json({ error: "内部服务器错误", details: error.message });
+    }
+});
+
+// 404处理
+app.use((req, res) => {
+    res.status(404).json({ message: "请使用正确请求路径" });
+});
+
+// 启动服务器
+app.listen(CONFIG.SERVER.PORT, () => {
+    console.log(`服务器运行在 http://localhost:${CONFIG.SERVER.PORT}`);
+});

package.json

@@ -0,0 +1,18 @@
+{
+  "name": "claudeServicee",
+  "version": "1.0.0",
+  "main": "index.js",
+  "type": "module",
+  "scripts": {
+    "start": "node index.js"
+  },
+  "author": "yxmiler",
+  "dependencies": {
+    "cors": "^2.8.5",
+    "crypto": "^1.0.1",
+    "dotenv": "^16.3.1",
+    "express": "^4.18.2",
+    "uuid": "^9.0.0",
+    "ws": "^8.18.0"
+  }
+}

worker.js

@@ -0,0 +1,171 @@
+/**
+ * Rate Limiting Proxy Worker with Sliding Window
+ */
+const LIMIT = 2; // 120秒内允许2个请求
+const WINDOW = 120; // 滑动窗口大小（秒）
+const TARGET_HOST = "https://example.com"; // 目标服务器
+
+async function updateRequestStats(ip, path, isSuccess, env) {
+    // 获取统计数据
+    const statsKey = `${ip}`;
+    let stats = await env.ad2api_ip_list.get(statsKey);
+    stats = stats
+        ? JSON.parse(stats)
+        : {
+              modelsCount: 0, // /v1/models 的请求次数
+              successCount: 0, // 成功请求的次数
+              hitMaxLimitCount: 0, // 到达最大限制的次数
+          };
+
+    // 更新统计
+    if (path === "/v1/models") {
+        stats.modelsCount++;
+    } else if (!isSuccess) {
+        stats.hitMaxLimitCount++;
+    } else {
+        stats.successCount++;
+    }
+
+    // 保存统计数据到 ad2api_ip_list
+    await env.ad2api_ip_list.put(statsKey, JSON.stringify(stats));
+
+    return stats;
+}
+
+async function checkRateLimit(ip, path, env) {
+    // 如果是 /v1/models 路径，不进行限流
+    if (path === "/v1/models") {
+        await updateRequestStats(ip, path, true, env);
+        return { allowed: true };
+    }
+
+    const now = Math.floor(Date.now() / 1000);
+    const key = `${ip}`;
+
+    // 获取请求历史记录
+    let history = await env.ad2api_rate_limits.get(key);
+    let timestamps = [];
+
+    if (history) {
+        timestamps = JSON.parse(history);
+        // 过滤掉超过窗口期的时间戳
+        timestamps = timestamps.filter((ts) => now - ts < WINDOW);
+    }
+
+    // 检查是否超过限制
+    if (timestamps.length >= LIMIT) {
+        // 计算最早的请求何时可以过期
+        const oldestTimestamp = timestamps[0];
+        const waitTime = WINDOW - (now - oldestTimestamp);
+        if (waitTime > 0) {
+            return { allowed: false, waitTime };
+        }
+        // 移除最早的请求
+        timestamps.shift();
+    }
+
+    // 添加新的请求时间戳
+    timestamps.push(now);
+
+    // 更新存储
+    await env.ad2api_rate_limits.put(key, JSON.stringify(timestamps), {
+        expirationTtl: WINDOW,
+    });
+
+    return { allowed: true };
+}
+
+async function handleRequest(request, env) {
+    const ip = request.headers.get("cf-connecting-ip");
+    const url = new URL(request.url);
+
+    // 检查速率限制
+    const result = await checkRateLimit(ip, url.pathname, env);
+    if (!result.allowed) {
+        return new Response("Too Many Requests", {
+            status: 429,
+            headers: {
+                "Content-Type": "text/plain",
+                "Retry-After": String(result.waitTime),
+                "Access-Control-Allow-Origin": "*",
+            },
+        });
+    }
+
+    // 构建目标 URL
+    const targetUrl = new URL(TARGET_HOST + url.pathname + url.search);
+
+    // 复制并修改请求头
+    const headers = new Headers(request.headers);
+    headers.set("Host", new URL(TARGET_HOST).host);
+
+    // 创建新的请求
+    const newRequest = new Request(targetUrl.toString(), {
+        method: request.method,
+        headers: headers,
+        body: request.body,
+        redirect: "follow",
+    });
+
+    try {
+        // 发送请求到目标服务器
+        const response = await fetch(newRequest);
+        const isSuccess = response.status !== 500;
+
+        // 更新统计
+        await updateRequestStats(ip, url.pathname, isSuccess, env);
+
+        // 如果是500错误，从速率限制历史中移除此次请求
+        if (!isSuccess) {
+            const key = `${ip}`;
+            let history = await env.ad2api_rate_limits.get(key);
+            if (history) {
+                let timestamps = JSON.parse(history);
+                timestamps.pop(); // 移除最后添加的时间戳
+                await env.ad2api_rate_limits.put(
+                    key,
+                    JSON.stringify(timestamps),
+                    {
+                        expirationTtl: WINDOW,
+                    }
+                );
+            }
+        }
+
+        // 创建响应头
+        const responseHeaders = new Headers(response.headers);
+        responseHeaders.set("Access-Control-Allow-Origin", "*");
+
+        // 返回流式响应
+        return new Response(response.body, {
+            status: response.status,
+            headers: responseHeaders,
+        });
+    } catch (error) {
+        // 处理异常为500错误
+        await updateRequestStats(ip, url.pathname, false, env);
+        // 从速率限制历史中移除此次请求
+        const key = `${ip}`;
+        let history = await env.ad2api_rate_limits.get(key);
+        if (history) {
+            let timestamps = JSON.parse(history);
+            timestamps.pop(); // 移除最后添加的时间戳
+            await env.ad2api_rate_limits.put(key, JSON.stringify(timestamps), {
+                expirationTtl: WINDOW,
+            });
+        }
+
+        return new Response("Internal Server Error", {
+            status: 500,
+            headers: {
+                "Access-Control-Allow-Origin": "*",
+            },
+        });
+    }
+}
+
+export default {
+    async fetch(request, env, ctx) {
+        return handleRequest(request, env);
+    },
+};