Update app.py

app.py

@@ -88,14 +88,19 @@ def load_model():
         logger.error(f"模型加载失败: {e}")
         return False
 
-def generate_response(prompt):
-    """极简响应生成 - 仅使用用户输入"""
+def generate_completion(prompt, max_tokens=256, temperature=0.7):
+    """生成OpenAI Completions格式的响应"""
     if model is None or tokenizer is None:
         return {"error": "模型未加载"}
     
     try:
-        # 手动构建提示
-        text = f"<|im_start|>user\n{prompt}<|im_end|>\n<|im_start|>assistant\n"
+        # 构建提示词 - 使用Qwen模型的对话格式
+        if "user" in prompt.lower() or "assistant" in prompt.lower():
+            # 如果提示词已经包含对话格式，直接使用
+            text = prompt
+        else:
+            # 否则，将提示词包装为对话格式
+            text = f"<|im_start|>user\n{prompt}<|im_end|>\n<|im_start|>assistant\n"
         
         # 编码输入
         inputs = tokenizer(text, return_tensors="pt", truncation=True, max_length=1024)
@@ -105,15 +110,25 @@ def generate_response(prompt):
         with torch.no_grad():
             outputs = model.generate(
                 **inputs,
-                max_new_tokens=MAX_TOKENS,
+                max_new_tokens=min(max_tokens, MAX_TOKENS),
                 do_sample=True,
-                temperature=0.7,
+                temperature=temperature,
                 top_p=0.9,
                 pad_token_id=tokenizer.eos_token_id
             )
         
-        # 解码响应
-        response = tokenizer.decode(outputs[0][len(inputs[0]):], skip_special_tokens=True)
+        # 解码完整响应（包括提示词和生成内容）
+        full_response = tokenizer.decode(outputs[0], skip_special_tokens=False)
+        
+        # 提取生成的文本（去除提示词部分）
+        if text in full_response:
+            generated_text = full_response[len(text):]
+        else:
+            # 如果提取失败，使用简单方法
+            generated_text = tokenizer.decode(outputs[0][len(inputs[0]):], skip_special_tokens=True)
+        
+        # 清理特殊标记
+        generated_text = generated_text.replace("<|im_end|>", "").strip()
         
         # 立即清理内存
         del inputs, outputs
@@ -121,7 +136,7 @@ def generate_response(prompt):
             torch.cuda.empty_cache()
         gc.collect()
         
-        return {"content": response.strip()}
+        return {"text": generated_text}
         
     except Exception as e:
         logger.error(f"生成响应失败: {e}")
@@ -129,9 +144,9 @@ def generate_response(prompt):
 
 # 创建极简FastAPI应用
 app = FastAPI(
-    title="OpenClaw专用API",
+    title="OpenAI Completions API兼容服务",
     version="1.0",
-    description="专为OpenClaw优化的API服务"
+    description="专为OpenClaw优化的OpenAI Completions API兼容服务"
 )
 
 # 启动时加载模型
@@ -142,19 +157,118 @@ async def startup_event():
     if API_AUTH_ENABLED:
         logger.info(f"有效的API密钥数量: {len(API_KEYS)}")
 
-# OpenClaw专用端点
-@app.post("/chat/completions")
-async def openclaw_chat_api(
+# 健康检查端点（无需认证）
+@app.get("/health")
+async def health_check():
+    return {
+        "status": "healthy" if model is not None else "loading",
+        "model_loaded": model is not None,
+        "api_auth_enabled": API_AUTH_ENABLED,
+        "timestamp": int(time.time())
+    }
+
+# 根端点（无需认证）
+@app.get("/")
+async def root():
+    return {
+        "message": "OpenAI Completions API兼容服务运行中",
+        "model_loaded": model is not None,
+        "api_auth_enabled": API_AUTH_ENABLED,
+        "endpoints": {
+            "completions": "/v1/completions",
+            "chat_completions": "/v1/chat/completions"
+        }
+    }
+
+# OpenAI Completions端点（OpenClaw主要使用这个）
+@app.post("/v1/completions")
+async def create_completion(
     request: Request,
     auth_valid: bool = Depends(verify_api_key)
 ):
-    """专为OpenClaw设计的API端点"""
+    """OpenAI Completions API兼容端点"""
+    try:
+        # 解析请求
+        data = await request.json()
+        prompt = data.get("prompt", "")
+        model_name = data.get("model", "qwen1.5-0.5b-chat")
+        max_tokens = data.get("max_tokens", MAX_TOKENS)
+        temperature = data.get("temperature", 0.7)
+        
+        if not prompt:
+            return JSONResponse(
+                status_code=400,
+                content={
+                    "error": {
+                        "message": "缺少必需的参数: prompt",
+                        "type": "invalid_request_error"
+                    }
+                }
+            )
+        
+        # 生成响应
+        result = generate_completion(prompt, max_tokens, temperature)
+        
+        if "error" in result:
+            return JSONResponse(
+                status_code=500,
+                content={
+                    "error": {
+                        "message": result["error"],
+                        "type": "internal_error"
+                    }
+                }
+            )
+        
+        # 返回OpenAI Completions兼容格式
+        return {
+            "id": f"cmpl-{int(time.time())}",
+            "object": "text_completion",
+            "created": int(time.time()),
+            "model": model_name,
+            "choices": [
+                {
+                    "text": result["text"],
+                    "index": 0,
+                    "logprobs": None,
+                    "finish_reason": "stop"
+                }
+            ],
+            "usage": {
+                "prompt_tokens": len(tokenizer.encode(prompt)) if tokenizer else 0,
+                "completion_tokens": len(tokenizer.encode(result["text"])) if tokenizer else 0,
+                "total_tokens": len(tokenizer.encode(prompt)) + len(tokenizer.encode(result["text"])) if tokenizer else 0
+            }
+        }
+        
+    except Exception as e:
+        logger.error(f"Completions API错误: {e}")
+        return JSONResponse(
+            status_code=500,
+            content={
+                "error": {
+                    "message": f"内部服务器错误: {str(e)}",
+                    "type": "internal_error"
+                }
+            }
+        )
+
+# 保持Chat Completions端点兼容性
+@app.post("/v1/chat/completions")
+async def create_chat_completion(
+    request: Request,
+    auth_valid: bool = Depends(verify_api_key)
+):
+    """OpenAI Chat Completions API兼容端点"""
     try:
         # 解析请求
         data = await request.json()
         messages = data.get("messages", [])
+        model_name = data.get("model", "qwen1.5-0.5b-chat")
+        max_tokens = data.get("max_tokens", MAX_TOKENS)
+        temperature = data.get("temperature", 0.7)
         
-        # 提取用户消息
+        # 从消息中提取用户提示
         user_message = ""
         for msg in messages:
             if msg.get("role") == "user":
@@ -165,49 +279,62 @@ async def openclaw_chat_api(
             return JSONResponse(
                 status_code=400,
                 content={
-                    "error": "未找到用户消息"
+                    "error": {
+                        "message": "未找到用户消息",
+                        "type": "invalid_request_error"
+                    }
                 }
             )
         
         # 生成响应
-        result = generate_response(user_message)
+        result = generate_completion(user_message, max_tokens, temperature)
         
         if "error" in result:
             return JSONResponse(
                 status_code=500,
                 content={
-                    "error": result["error"]
+                    "error": {
+                        "message": result["error"],
+                        "type": "internal_error"
+                    }
                 }
             )
         
-        # 返回OpenClaw专用格式
+        # 返回OpenAI Chat Completions兼容格式
         return {
-            "choices": [{
-                "message": {
-                    "content": result["content"]
+            "id": f"chatcmpl-{int(time.time())}",
+            "object": "chat.completion",
+            "created": int(time.time()),
+            "model": model_name,
+            "choices": [
+                {
+                    "index": 0,
+                    "message": {
+                        "role": "assistant",
+                        "content": result["text"]
+                    },
+                    "finish_reason": "stop"
                 }
-            }]
+            ],
+            "usage": {
+                "prompt_tokens": len(tokenizer.encode(user_message)) if tokenizer else 0,
+                "completion_tokens": len(tokenizer.encode(result["text"])) if tokenizer else 0,
+                "total_tokens": len(tokenizer.encode(user_message)) + len(tokenizer.encode(result["text"])) if tokenizer else 0
+            }
         }
         
     except Exception as e:
-        logger.error(f"OpenClaw API错误: {e}")
+        logger.error(f"Chat Completions API错误: {e}")
         return JSONResponse(
             status_code=500,
             content={
-                "error": f"内部服务器错误: {str(e)}"
+                "error": {
+                    "message": f"内部服务器错误: {str(e)}",
+                    "type": "internal_error"
+                }
             }
         )
 
-# 健康检查端点
-@app.get("/health")
-async def health_check():
-    return {
-        "status": "healthy" if model is not None else "loading",
-        "model_loaded": model is not None,
-        "api_auth_enabled": API_AUTH_ENABLED,
-        "timestamp": int(time.time())
-    }
-
 if __name__ == "__main__":
     import uvicorn