Upload 4 files

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"]

README.md

@@ -1,10 +1,10 @@
----
-title: Claudedoc2
-emoji: ⚡
-colorFrom: pink
-colorTo: yellow
-sdk: docker
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+---
+title: Claudedoc2
+emoji: 🦀
+colorFrom: green
+colorTo: indigo
+sdk: docker
+pinned: false
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

index.js

@@ -0,0 +1,363 @@
+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) {
+      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 responseContent = '';
+          let isComplete = false;
+
+          ws.on('open', () => {
+              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);
+              
+              switch (parsedMessage.type) {
+                  case 'connection_ack':
+                      console.log('WebSocket连接请求中');
+                      this.sendChatSubscription(ws, requestPayload);
+                      break;
+                  case 'next':
+                      const chatResponse = await this.handleChatResponse(parsedMessage);
+                      if (chatResponse) {
+                          responseContent = chatResponse;
+                      }
+                      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('请求完毕，关闭连接');
+              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
+                  }
+              }`
+          }
+      };
+
+      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('/hf/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('/hf/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: "缺失用户消息" });
+      }
+
+      const responseContent = await WebSocketUtils.createWebSocketClient(requestPayload);
+
+      if (stream) {
+          await ResponseHandler.handleStreamResponse(responseContent, model, res);
+      } else {
+          await ResponseHandler.handleNormalResponse(userMessage, responseContent, model, res);
+      }
+  } catch (error) {
+      console.error('处理请求时发生错误:', error);
+      res.status(500).json({ error: "内部服务器错误", details: error.message });
+  }
+});
+
+// root
+app.get('/', (req, res) => {
+  res.json({ message: "app running" });
+});
+
+// 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"
+  }
+}