Upload 10 files

.cnb.yml

@@ -1,4 +1,4 @@
-"(main)":
+"(main|dev)":
   push:
     - runner:
         cpus: 2

README.md

@@ -1,11 +1,13 @@
----
-title: Julep2api
-emoji: 🔥
-colorFrom: pink
-colorTo: red
-sdk: docker
-pinned: false
-app_port: 8080
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+## 部署到 claw cloud
+
+image: docker.cnb.cool/0_0/learn/julep
+端口： 8080
+cpu: 0.2
+内存: 64M
+环境变量: JULEP_API_BASE_URL=https://api.julep.ai/api
+
+如果跟 new-api 部署在同一个区域，可以让 new-api 直接用内网地址连接到 julep。无需暴露到公网。
+
+## 致谢
+
+https://linux.do/t/topic/577836/27

handlers.go

@@ -19,7 +19,7 @@ func chatCompletionsHandler(logger *slog.Logger, w http.ResponseWriter, r *http.
 	// ... (Keep Method Check, Authentication, Decode Body, Validation as before) ...
 	// 1. Check Method
 	if r.Method != http.MethodPost {
-		writeJSONError(w, reqLogger, http.StatusMethodNotAllowed, fmt.Sprintf("Method %s not allowed", r.Method), stringPtr("invalid_request_error"), nil, nil)
+		writeJSONError(w, reqLogger, http.StatusMethodNotAllowed, fmt.Sprintf("方法 %s 不允许", r.Method), stringPtr("invalid_request_error"), nil, nil) // Example Chinese error
 		return
 	}
 
@@ -30,7 +30,7 @@ func chatCompletionsHandler(logger *slog.Logger, w http.ResponseWriter, r *http.
 		if authHeader != "" {
 			invalidAuthType = "invalid_authorization_type"
 		}
-		writeJSONError(w, reqLogger, http.StatusUnauthorized, "Authorization header is required (e.g., 'Bearer YOUR_API_KEY')", &invalidAuthType, nil, nil)
+		writeJSONError(w, reqLogger, http.StatusUnauthorized, "需要 Authorization 标头 (例如, 'Bearer YOUR_API_KEY')", &invalidAuthType, nil, nil) // Example Chinese error
 		return
 	}
 	reqLogger.Debug("Authorization header present") // Changed to Debug
@@ -42,15 +42,15 @@ func chatCompletionsHandler(logger *slog.Logger, w http.ResponseWriter, r *http.
 	if err != nil {
 		var syntaxError *json.SyntaxError
 		var unmarshalTypeError *json.UnmarshalTypeError
-		errMsg := "Invalid JSON request body"
+		errMsg := "无效的 JSON 请求体" // Example Chinese error
 		errCode := "invalid_json"
 		if errors.As(err, &syntaxError) { // Use errors.As
-			errMsg = fmt.Sprintf("Invalid JSON syntax at offset %d", syntaxError.Offset)
+			errMsg = fmt.Sprintf("偏移量 %d 处 JSON 语法无效", syntaxError.Offset) // Example Chinese error
 		} else if errors.As(err, &unmarshalTypeError) { // Use errors.As
-			errMsg = fmt.Sprintf("Invalid type for field '%s', expected %s", unmarshalTypeError.Field, unmarshalTypeError.Type)
+			errMsg = fmt.Sprintf("字段 '%s' 类型无效，应为 %s", unmarshalTypeError.Field, unmarshalTypeError.Type) // Example Chinese error
 			errCode = "invalid_field_type"
 		} else if err.Error() == "http: request body too large" {
-			errMsg = "Request body exceeds limit (1MB)"
+			errMsg = "请求体超过限制 (1MB)" // Example Chinese error
 			errCode = "request_too_large"
 			writeJSONError(w, reqLogger, http.StatusRequestEntityTooLarge, errMsg, stringPtr("invalid_request_error"), &errCode, nil)
 			return
@@ -66,14 +66,14 @@ func chatCompletionsHandler(logger *slog.Logger, w http.ResponseWriter, r *http.
 		reqLogger.Warn("Validation failed: 'messages' field is empty")
 		param := "messages"
 		code := "missing_field"
-		writeJSONError(w, reqLogger, http.StatusBadRequest, "'messages' is a required field and must be a non-empty array", stringPtr("invalid_request_error"), &code, &param)
+		writeJSONError(w, reqLogger, http.StatusBadRequest, "'messages' 是必填字段且必须是非空数组", stringPtr("invalid_request_error"), &code, &param) // Example Chinese error
 		return
 	}
 	if openaiRequest.Model == "" {
 		reqLogger.Warn("Validation failed: 'model' field is empty")
 		param := "model"
 		code := "missing_field"
-		writeJSONError(w, reqLogger, http.StatusBadRequest, "'model' is a required field", stringPtr("invalid_request_error"), &code, &param)
+		writeJSONError(w, reqLogger, http.StatusBadRequest, "'model' 是必填字段", stringPtr("invalid_request_error"), &code, &param) // Example Chinese error
 		return
 	}
 	reqLogger.Info("Request decoded and validated", "model", openaiRequest.Model, "stream_requested", openaiRequest.Stream)
@@ -86,12 +86,14 @@ func chatCompletionsHandler(logger *slog.Logger, w http.ResponseWriter, r *http.
 		reqLogger.Error("Upstream Julep call failed", "error", err, "status_code", upstreamStatusCode)
 		// Use the status code returned by callJulepChat for the client response
 		errType := "upstream_error"
+		errMsg := fmt.Sprintf("上游 API 错误: %s", err.Error()) // Example Chinese error
 		if upstreamStatusCode == http.StatusGatewayTimeout {
 			errType = "gateway_timeout"
+			errMsg = fmt.Sprintf("上游 API 超时: %s", err.Error()) // Example Chinese error
 		} else if upstreamStatusCode >= 400 && upstreamStatusCode < 500 {
 			errType = "invalid_request_error" // Or map specific Julep 4xx codes
 		}
-		writeJSONError(w, reqLogger, upstreamStatusCode, fmt.Sprintf("Upstream API error: %s", err.Error()), &errType, nil, nil)
+		writeJSONError(w, reqLogger, upstreamStatusCode, errMsg, &errType, nil, nil)
 		return
 	}
 
@@ -101,7 +103,8 @@ func chatCompletionsHandler(logger *slog.Logger, w http.ResponseWriter, r *http.
 	if !isStreaming {
 		// 6.a. Send Non-Streaming Response
 		reqLogger.Info("Sending non-streaming response")
-		w.Header().Set("Content-Type", "application/json")
+		// CORRECTED: Explicitly add charset=utf-8
+		w.Header().Set("Content-Type", "application/json; charset=utf-8")
 		w.WriteHeader(http.StatusOK) // Status OK as the overall operation succeeded
 		if err := json.NewEncoder(w).Encode(finalOpenAIResponse); err != nil {
 			reqLogger.Error("Failed to encode non-streaming response", "error", err)
@@ -110,7 +113,8 @@ func chatCompletionsHandler(logger *slog.Logger, w http.ResponseWriter, r *http.
 		// 6.b. Send Simulated Streaming Response from the complete Julep data
 		reqLogger.Info("Sending simulated streaming response based on Julep result")
 
-		w.Header().Set("Content-Type", "text/event-stream")
+		// CORRECTED: Explicitly add charset=utf-8
+		w.Header().Set("Content-Type", "text/event-stream; charset=utf-8")
 		w.Header().Set("Cache-Control", "no-cache")
 		w.Header().Set("Connection", "keep-alive")
 		// Optional: w.Header().Set("X-Accel-Buffering", "no")
@@ -119,11 +123,12 @@ func chatCompletionsHandler(logger *slog.Logger, w http.ResponseWriter, r *http.
 		if !ok {
 			reqLogger.Error("Streaming unsupported: ResponseWriter does not implement http.Flusher")
 			errType := "internal_server_error"
+			errMsg := "内部服务器错误：流式传输不受支持" // Example Chinese error
 			// It's likely too late to send a proper JSON error here if headers were already flushed implicitly.
 			// Best effort: log and potentially send plain text error before trying to write stream headers.
-			http.Error(w, "Internal Server Error: Streaming unsupported", http.StatusInternalServerError)
+			http.Error(w, errMsg, http.StatusInternalServerError)
 			// Attempt to write JSON error anyway, might fail.
-			writeJSONError(w, reqLogger, http.StatusInternalServerError, "Streaming is not supported by the server configuration", &errType, nil, nil)
+			writeJSONError(w, reqLogger, http.StatusInternalServerError, "服务器配置不支持流式传输", &errType, nil, nil) // Example Chinese error
 			return
 		}
 
@@ -144,13 +149,14 @@ func chatCompletionsHandler(logger *slog.Logger, w http.ResponseWriter, r *http.
 
 // streamFullResponseAsChunks takes a complete OpenAIResponse and sends it
 // to the client as a series of SSE chunks, simulating a real stream.
+// (No changes needed inside this function itself, as it relies on the Content-Type set before calling it)
 func streamFullResponseAsChunks(w http.ResponseWriter, flusher http.Flusher, logger *slog.Logger, fullResp *OpenAIResponse) error {
 	if len(fullResp.Choices) == 0 {
 		logger.Warn("Full response has no choices to stream")
 		// Send DONE immediately if no choices
 		_, err := fmt.Fprintf(w, "data: [DONE]\n\n")
 		if err != nil {
-			return fmt.Errorf("failed to write [DONE] message: %w", err)
+			return fmt.Errorf("写入 [DONE] 消息失败: %w", err) // Example Chinese error
 		}
 		flusher.Flush()
 		return nil
@@ -175,7 +181,7 @@ func streamFullResponseAsChunks(w http.ResponseWriter, flusher http.Flusher, log
 			},
 		}
 		if err := sendChunk(w, flusher, logger, roleChunk); err != nil {
-			return fmt.Errorf("failed to send role chunk: %w", err)
+			return fmt.Errorf("发送角色块失败: %w", err) // Example Chinese error
 		}
 		time.Sleep(10 * time.Millisecond) // Small delay
 	}
@@ -185,12 +191,21 @@ func streamFullResponseAsChunks(w http.ResponseWriter, flusher http.Flusher, log
 	if content != "" {
 		// Simulate streaming by breaking content into smaller parts
 		const chunkSize = 5 // Small chunk size for demonstration
-		for i := 0; i < len(content); i += chunkSize {
-			end := i + chunkSize
-			if end > len(content) {
-				end = len(content)
+		// IMPORTANT: This simple byte-wise chunking can break multi-byte UTF-8 characters.
+		// For proper UTF-8 streaming, chunking should happen at rune boundaries.
+		// However, since we are simulating from a *complete* response here, and
+		// sendChunk uses json.Marshal which handles UTF-8 correctly, this simulation
+		// *should* still produce valid JSON payloads per chunk. The potential issue
+		// is less severe than if we were reading a raw byte stream.
+		// A more robust simulation would iterate over runes.
+		runeContent := []rune(content)
+		const runeChunkSize = 3 // Chunk runes instead of bytes
+		for i := 0; i < len(runeContent); i += runeChunkSize {
+			end := i + runeChunkSize
+			if end > len(runeContent) {
+				end = len(runeContent)
 			}
-			contentPiece := content[i:end]
+			contentPiece := string(runeContent[i:end]) // Convert rune slice back to string
 
 			contentChunk := OpenAIChunk{
 				ID:      fullResp.ID,
@@ -206,7 +221,7 @@ func streamFullResponseAsChunks(w http.ResponseWriter, flusher http.Flusher, log
 				},
 			}
 			if err := sendChunk(w, flusher, logger, contentChunk); err != nil {
-				return fmt.Errorf("failed to send content chunk: %w", err)
+				return fmt.Errorf("发送内容块失败: %w", err) // Example Chinese error
 			}
 			time.Sleep(30 * time.Millisecond) // Simulate generation time between chunks
 		}
@@ -228,7 +243,7 @@ func streamFullResponseAsChunks(w http.ResponseWriter, flusher http.Flusher, log
 			},
 		}
 		if err := sendChunk(w, flusher, logger, toolChunk); err != nil {
-			return fmt.Errorf("failed to send tool_calls chunk: %w", err)
+			return fmt.Errorf("发送 tool_calls 块失败: %w", err) // Example Chinese error
 		}
 		time.Sleep(10 * time.Millisecond) // Small delay
 	}
@@ -248,7 +263,7 @@ func streamFullResponseAsChunks(w http.ResponseWriter, flusher http.Flusher, log
 		},
 	}
 	if err := sendChunk(w, flusher, logger, finalChunk); err != nil {
-		return fmt.Errorf("failed to send final chunk: %w", err)
+		return fmt.Errorf("发送最终块失败: %w", err) // Example Chinese error
 	}
 
 	// --- Send DONE message ---
@@ -257,7 +272,7 @@ func streamFullResponseAsChunks(w http.ResponseWriter, flusher http.Flusher, log
 	if err != nil {
 		// Log error, but might not reach client if connection closed
 		logger.Error("Failed to write [DONE] message", "error", err)
-		return fmt.Errorf("failed to write [DONE] message: %w", err)
+		return fmt.Errorf("写入 [DONE] 消息失败: %w", err) // Example Chinese error
 	}
 	flusher.Flush() // Ensure DONE is sent
 
@@ -265,19 +280,22 @@ func streamFullResponseAsChunks(w http.ResponseWriter, flusher http.Flusher, log
 }
 
 // sendChunk encodes the chunk to JSON and writes it in SSE format.
+// (No changes needed here as json.Marshal produces UTF-8 and Fprintf respects it)
 func sendChunk(w http.ResponseWriter, flusher http.Flusher, logger *slog.Logger, chunk OpenAIChunk) error {
+	// json.Marshal correctly handles Go strings (UTF-8) into JSON strings (UTF-8)
 	chunkBytes, err := json.Marshal(chunk)
 	if err != nil {
 		logger.Error("Failed to marshal stream chunk", "error", err, "chunk_id", chunk.ID)
-		return fmt.Errorf("failed to marshal chunk: %w", err)
+		return fmt.Errorf("块编码失败: %w", err) // Example Chinese error
 	}
 
 	// Write in Server-Sent Event format: data: <json>\n\n
+	// fmt.Fprintf handles UTF-8 correctly when writing strings/byte slices
 	_, err = fmt.Fprintf(w, "data: %s\n\n", string(chunkBytes))
 	if err != nil {
 		// Log error, connection might be closed by client
 		logger.Error("Failed to write chunk to response writer", "error", err, "chunk_id", chunk.ID)
-		return fmt.Errorf("failed to write chunk: %w", err)
+		return fmt.Errorf("块写入失败: %w", err) // Example Chinese error
 	}
 
 	// Flush the buffer to send the chunk immediately

utils.go

@@ -10,7 +10,8 @@ import (
 
 // writeJSONError sends a standard JSON error response.
 func writeJSONError(w http.ResponseWriter, logger *slog.Logger, statusCode int, message string, errType *string, errCode *string, param *string) {
-	w.Header().Set("Content-Type", "application/json")
+	// CORRECTED: Explicitly add charset=utf-8
+	w.Header().Set("Content-Type", "application/json; charset=utf-8")
 	w.WriteHeader(statusCode)
 	resp := ErrorResponse{
 		Error: APIError{