使用官方示例代码结构，简化实现，固定依赖版本

app.py

@@ -1,18 +1,11 @@
 import gradio as gr
 import time
 import base64
+from openai import OpenAI
 import os
 from io import BytesIO
 from PIL import Image
 
-# 清理环境变量中的代理设置，避免与 OpenAI 客户端冲突
-for key in list(os.environ.keys()):
-    if 'proxy' in key.lower() or 'PROXY' in key:
-        del os.environ[key]
-
-# 导入 OpenAI（在清理环境变量后）
-from openai import OpenAI
-
 # 配置
 BASE_URL = "https://api.stepfun.com/v1"
 # 从环境变量获取API密钥
@@ -29,53 +22,11 @@ def image_to_base64(image):
     if isinstance(image, Image.Image):
         buffered = BytesIO()
         image.save(buffered, format="PNG")
-        img_str = base64.b64encode(buffered.getvalue()).decode()
+        img_str = base64.b64encode(buffered.getvalue()).decode('utf-8')
         return img_str
     
     return None
 
-def create_client():
-    """创建 OpenAI 客户端，处理各种环境问题"""
-    import importlib
-    import sys
-    
-    # 重新加载 openai 模块以确保干净的状态
-    if 'openai' in sys.modules:
-        importlib.reload(sys.modules['openai'])
-    
-    # 尝试不同的初始化方式
-    try:
-        # 方式1：只传递必需参数
-        return OpenAI(
-            api_key=STEP_API_KEY,
-            base_url=BASE_URL
-        )
-    except:
-        pass
-    
-    try:
-        # 方式2：通过环境变量
-        os.environ['OPENAI_API_KEY'] = STEP_API_KEY
-        os.environ['OPENAI_BASE_URL'] = BASE_URL
-        return OpenAI()
-    except:
-        pass
-    
-    # 方式3：使用 httpx 客户端自定义
-    try:
-        import httpx
-        http_client = httpx.Client()
-        return OpenAI(
-            api_key=STEP_API_KEY,
-            base_url=BASE_URL,
-            http_client=http_client
-        )
-    except:
-        pass
-    
-    # 如果都失败，返回 None
-    return None
-
 def call_step_api(image, prompt, model, temperature=0.7, max_tokens=2000):
     """调用Step API进行分析，支持纯文本和图像+文本"""
     
@@ -87,7 +38,7 @@ def call_step_api(image, prompt, model, temperature=0.7, max_tokens=2000):
         yield "", "❌ API密钥未配置。请在 Hugging Face Space 的 Settings 中添加 STEP_API_KEY 环境变量。"
         return
     
-    # 构造消息内容
+    # 构造消息内容 - 参考官方示例
     if image is not None:
         # 有图片的情况
         try:
@@ -95,109 +46,55 @@ def call_step_api(image, prompt, model, temperature=0.7, max_tokens=2000):
             if base64_image is None:
                 yield "", "❌ 图片处理失败"
                 return
-                
-            message_content = [
-                {
-                    "type": "image_url",
-                    "image_url": {
-                        "url": f"data:image/png;base64,{base64_image}",
-                        "detail": "high"
-                    }
-                },
-                {
-                    "type": "text",
-                    "text": prompt
-                }
+            
+            # 按照官方示例的格式构造消息
+            messages = [
+                {"role": "user", "content": [
+                    {"type": "image_url", "image_url": {"url": f"data:image/jpg;base64,{base64_image}", "detail": "high"}},
+                    {"type": "text", "text": prompt}
+                ]}
             ]
         except Exception as e:
             yield "", f"❌ 图片处理错误: {str(e)}"
             return
     else:
         # 纯文本的情况
-        message_content = prompt
+        messages = [
+            {"role": "user", "content": prompt}
+        ]
     
-    # 构造消息
-    messages = [
-        {
-            "role": "user",
-            "content": message_content
-        }
-    ]
-    
-    # 创建OpenAI客户端
-    client = create_client()
-    if client is None:
-        # 如果客户端创建失败，尝试直接使用 requests
-        try:
-            import requests
-            
-            headers = {
-                "Authorization": f"Bearer {STEP_API_KEY}",
-                "Content-Type": "application/json"
-            }
-            
-            data = {
-                "model": model,
-                "messages": messages,
-                "temperature": temperature,
-                "max_tokens": max_tokens,
-                "stream": False
-            }
-            
-            response = requests.post(
-                f"{BASE_URL}/chat/completions",
-                headers=headers,
-                json=data,
-                timeout=60
-            )
-            
-            if response.status_code == 200:
-                result = response.json()
-                if result.get("choices") and result["choices"][0].get("message"):
-                    content = result["choices"][0]["message"]["content"]
-                    
-                    # 解析 reasoning 标记
-                    reasoning_content = ""
-                    final_answer = content
-                    
-                    if "<reasoning>" in content and "</reasoning>" in content:
-                        parts = content.split("<reasoning>")
-                        before = parts[0]
-                        after_reasoning = parts[1].split("</reasoning>")
-                        reasoning_content = after_reasoning[0]
-                        final_answer = before + after_reasoning[1] if len(after_reasoning) > 1 else before
-                    
-                    yield reasoning_content, final_answer
-                else:
-                    yield "", "❌ API 返回格式错误"
-            else:
-                yield "", f"❌ API 请求失败: {response.status_code}"
-                
-        except Exception as e:
-            yield "", f"❌ 请求失败: {str(e)}"
+    # 创建OpenAI客户端 - 完全按照官方示例
+    try:
+        client = OpenAI(api_key=STEP_API_KEY, base_url=BASE_URL)
+    except Exception as e:
+        yield "", f"❌ 客户端初始化失败: {str(e)}"
         return
     
+    # 记录开始时间
+    start_time = time.time()
+    
     try:
-        # 记录开始时间
-        start_time = time.time()
-        
-        # 流式输出
+        # 调用API - 按照官方示例
         response = client.chat.completions.create(
             model=model,
             messages=messages,
-            temperature=temperature,
-            max_tokens=max_tokens,
             stream=True
         )
-        
-        full_response = ""
-        reasoning_content = ""
-        final_answer = ""
-        is_reasoning = False
-        reasoning_started = False
-        
+    except Exception as e:
+        yield "", f"❌ API请求失败: {str(e)}"
+        return
+    
+    # 处理流式响应
+    full_response = ""
+    reasoning_content = ""
+    final_answer = ""
+    is_reasoning = False
+    reasoning_started = False
+    
+    try:
         for chunk in response:
-            if chunk.choices and chunk.choices[0].delta:
+            # 按照官方示例处理chunk
+            if chunk.choices and len(chunk.choices) > 0:
                 delta = chunk.choices[0].delta
                 
                 if hasattr(delta, 'content') and delta.content:
@@ -208,47 +105,38 @@ def call_step_api(image, prompt, model, temperature=0.7, max_tokens=2000):
                     if "<reasoning>" in content:
                         is_reasoning = True
                         reasoning_started = True
-                        # 提取<reasoning>之前的内容添加到final_answer
-                        before_reasoning = content.split("<reasoning>")[0]
-                        if before_reasoning:
-                            final_answer += before_reasoning
-                        # 提取<reasoning>之后的内容开始reasoning
-                        after_tag = content.split("<reasoning>")[1] if len(content.split("<reasoning>")) > 1 else ""
-                        reasoning_content += after_tag
+                        # 处理标记前后的内容
+                        parts = content.split("<reasoning>")
+                        if parts[0]:
+                            final_answer += parts[0]
+                        if len(parts) > 1:
+                            reasoning_content += parts[1]
                     elif "</reasoning>" in content:
-                        # 提取</reasoning>之前的内容添加到reasoning
-                        before_tag = content.split("</reasoning>")[0]
-                        reasoning_content += before_tag
+                        # 处理结束标记
+                        parts = content.split("</reasoning>")
+                        if parts[0]:
+                            reasoning_content += parts[0]
                         is_reasoning = False
-                        # 提取</reasoning>之后的内容添加到final_answer
-                        after_reasoning = content.split("</reasoning>")[1] if len(content.split("</reasoning>")) > 1 else ""
-                        final_answer += after_reasoning
+                        if len(parts) > 1:
+                            final_answer += parts[1]
                     elif is_reasoning:
                         reasoning_content += content
                     else:
                         final_answer += content
                     
                     # 实时输出
-                    if reasoning_started:
-                        yield reasoning_content, final_answer
-                    else:
-                        yield "", final_answer
-        
-        # 添加生成时间
-        elapsed_time = time.time() - start_time
-        time_info = f"\n\n⏱️ 生成用时: {elapsed_time:.2f}秒"
-        final_answer += time_info
-        
-        yield reasoning_content, final_answer
-                
+                    yield reasoning_content, final_answer
+    
     except Exception as e:
-        error_msg = str(e)
-        if "api_key" in error_msg.lower():
-            yield "", "❌ API密钥错误：请检查密钥是否有效"
-        elif "network" in error_msg.lower() or "connection" in error_msg.lower():
-            yield "", "❌ 网络连接错误：请检查网络连接"
-        else:
-            yield "", f"❌ API调用错误: {error_msg[:200]}"
+        yield reasoning_content, final_answer + f"\n\n❌ 流处理错误: {str(e)}"
+        return
+    
+    # 添加生成时间
+    elapsed_time = time.time() - start_time
+    time_info = f"\n\n⏱️ 生成用时: {elapsed_time:.2f}秒"
+    final_answer += time_info
+    
+    yield reasoning_content, final_answer
 
 # 创建Gradio界面
 with gr.Blocks(title="Step-3", theme=gr.themes.Soft()) as demo:

requirements.txt

@@ -1,5 +1,3 @@
 gradio==4.19.2
-openai>=1.0.0,<2.0.0
-Pillow>=10.0.0
-httpx>=0.24.0
-requests>=2.25.0
+openai==1.12.0
+Pillow==10.2.0