Update main.ts

main.ts

@@ -1,3 +1,4 @@
+// main.ts
 import { serve } from "https://deno.land/std@0.208.0/http/server.ts";
 
 // --- 常量定义 ---
@@ -12,7 +13,7 @@ interface OpenAIMessage {
     type: string;
     text?: string;
     image_url?: { url: string };
-    document?: { url: string; type: string }; // 支持多种文档类型
+    document?: { url: string; type: string };
   }>;
 }
 
@@ -25,8 +26,8 @@ interface OpenAIRequest {
 }
 
 interface OpenAITTSRequest {
-    model: string; 
-    input: string; 
+    model: string;
+    input: string;
     voice: 'alloy' | 'echo' | 'fable' | 'onyx' | 'nova' | 'shimmer';
     response_format?: 'mp3' | 'opus' | 'aac' | 'flac';
     speed?: number;
@@ -61,16 +62,10 @@ class GoogleAIService {
     return key;
   }
   
-  // --- [新增] TTS 功能 ---
   private getGoogleVoice(openAIVoice: string): string {
     const voiceMap: { [key: string]: string } = {
-        'alloy': 'Kore',      
-        'echo': 'Sal',        
-        'fable': 'Polly',     
-        'onyx': 'Onyx',       
-        'nova': 'Sparkle',    
-        'shimmer': 'Luna',    
-        'default': 'Kore'
+        'alloy': 'Kore', 'echo': 'Sal', 'fable': 'Polly', 'onyx': 'Onyx',
+        'nova': 'Sparkle', 'shimmer': 'Luna', 'default': 'Kore'
     };
     return voiceMap[openAIVoice] || voiceMap['default'];
   }
@@ -81,70 +76,43 @@ class GoogleAIService {
     const ttsModel = "gemini-2.5-flash-preview-tts"; 
 
     console.log(`Generating speech with model: ${ttsModel}, voice: ${googleVoice} (mapped from OpenAI's '${voice}')`);
-
     const requestBody = {
         "contents": [{"parts":[{"text": input}]}],
-        "generationConfig": {
-            "responseModalities": ["AUDIO"],
-            "speechConfig": {"voiceConfig": {"prebuiltVoiceConfig": {"voiceName": googleVoice}}}
-        },
+        "generationConfig": {"responseModalities": ["AUDIO"],"speechConfig": {"voiceConfig": {"prebuiltVoiceConfig": {"voiceName": googleVoice}}}},
         "model": ttsModel,
     };
-
-    const response = await fetch(
-        `https://generativelanguage.googleapis.com/v1beta/models/${ttsModel}:generateContent?key=${apiKey}`,
-        { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify(requestBody) }
-    );
-
+    const response = await fetch(`https://generativelanguage.googleapis.com/v1beta/models/${ttsModel}:generateContent?key=${apiKey}`,
+        { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify(requestBody) });
     if (!response.ok) {
         const errorBody = await response.json().catch(() => response.text());
         const errorMessage = errorBody?.error?.message || JSON.stringify(errorBody);
-        console.error(`Google TTS API Error: ${response.status} - ${errorMessage}`);
         throw new Error(`Google TTS API request failed with status ${response.status}: ${errorMessage}`);
     }
-
     const data = await response.json();
     const audioContentBase64 = data.candidates?.[0]?.content?.parts?.[0]?.inlineData?.data;
-    if (!audioContentBase64) {
-        throw new Error("No audio data returned from Google API. The response might be blocked or empty.");
-    }
-    
+    if (!audioContentBase64) throw new Error("No audio data returned from Google API.");
     const binaryString = atob(audioContentBase64);
-    const len = binaryString.length;
-    const bytes = new Uint8Array(len);
-    for (let i = 0; i < len; i++) {
+    const bytes = new Uint8Array(binaryString.length);
+    for (let i = 0; i < binaryString.length; i++) {
         bytes[i] = binaryString.charCodeAt(i);
     }
     return bytes.buffer;
   }
   
-  // --- 模型处理等现有代码保持不变 ---
-  
-  async fetchOfficialModels(): Promise<any[]> { /* ... 保持不变 ... */
+  async fetchOfficialModels(): Promise<any[]> {
     const now = Date.now();
-    if (this.cachedModels.length > 0 && (now - this.modelsLastFetch) < MODELS_CACHE_DURATION) {
-      return this.cachedModels;
-    }
-
+    if (this.cachedModels.length > 0 && (now - this.modelsLastFetch) < MODELS_CACHE_DURATION) return this.cachedModels;
     const apiKey = this.getNextApiKey();
     try {
-      const response = await fetch(
-        `https://generativelanguage.googleapis.com/v1beta/models?key=${apiKey}`,
-        { method: "GET", headers: { "Content-Type": "application/json" } }
-      );
-
+      const response = await fetch(`https://generativelanguage.googleapis.com/v1beta/models?key=${apiKey}`);
       if (!response.ok) {
         console.warn(`Failed to fetch models from Google AI: ${response.status}. Using fallback models.`);
         return this.getFallbackModels();
       }
-
       const data = await response.json();
       if (data.models && Array.isArray(data.models)) {
-        this.cachedModels = data.models.filter((model: any) =>
-          model.supportedGenerationMethods?.includes('generateContent')
-        );
+        this.cachedModels = data.models.filter((model: any) => model.supportedGenerationMethods?.includes('generateContent'));
         this.modelsLastFetch = now;
-        console.log(`Fetched ${this.cachedModels.length} models from Google AI`);
         return this.cachedModels;
       }
       return this.getFallbackModels();
@@ -154,98 +122,120 @@ class GoogleAIService {
     }
   }
 
-  private getFallbackModels(): any[] { /* ... 保持不变 ... */
+  private getFallbackModels(): any[] {
     return [
-      { name: "models/gemini-1.5-pro", displayName: "Gemini 1.5 Pro", description: "Mid-size multimodal model that supports up to 1 million tokens, images, and documents (PDF, TXT, MD)", supportedGenerationMethods: ["generateContent"], maxTokens: 1000000, supportsDocuments: true },
-      { name: "models/gemini-1.5-flash", displayName: "Gemini 1.5 Flash", description: "Fast and versatile multimodal model for diverse tasks, supports images and documents (PDF, TXT, MD)", supportedGenerationMethods: ["generateContent"], maxTokens: 1000000, supportsDocuments: true },
-      { name: "models/gemini-2.0-flash-preview-image-generation", displayName: "Gemini 2.0 Flash Image Generation", description: "Advanced model for generating and editing high-quality images with text and image outputs", supportedGenerationMethods: ["generateContent"], maxTokens: 100000, capabilities: ["text", "image_generation", "image_editing"] },
-      { name: "models/gemini-2.5-flash-preview-tts", displayName: "Gemini 2.5 Flash TTS", description: "Text-to-speech model for generating high-quality audio.", supportedGenerationMethods: ["generateContent"], id: "gemini-2.5-flash-preview-tts" }
+      { name: "models/gemini-1.5-pro", displayName: "Gemini 1.5 Pro", description: "Mid-size multimodal model that supports up to 1 million tokens.", supportedGenerationMethods: ["generateContent"], maxTokens: 1000000 },
+      { name: "models/gemini-1.5-flash", displayName: "Gemini 1.5 Flash", description: "Fast and versatile multimodal model.", supportedGenerationMethods: ["generateContent"], maxTokens: 1000000 },
+      { name: "models/gemini-2.0-flash-preview-image-generation", displayName: "Gemini 2.0 Flash Image Generation", description: "Advanced model for generating images.", supportedGenerationMethods: ["generateContent"], maxTokens: 100000 },
+      { name: "models/gemini-2.5-flash-preview-tts", displayName: "Gemini 2.5 Flash TTS", description: "Text-to-speech model.", id: "gemini-2.5-flash-preview-tts" }
     ];
   }
 
   public isVisionModel = (modelName: string): boolean => modelName.toLowerCase().includes('vision') || modelName.toLowerCase().includes('pro');
-  public isImageGenerationModel = (modelName: string): boolean => modelName.includes('image-generation') || modelName === 'gemini-2.0-flash-preview-image-generation';
-  public isImageEditingModel = (modelName: string): boolean => modelName.includes('image-generation') || modelName === 'gemini-2.0-flash-preview-image-generation';
-  public isDocumentModel = (modelName: string): boolean => modelName.toLowerCase().includes('gemini-1.5') || modelName.toLowerCase().includes('pro') || modelName.toLowerCase().includes('flash');
+  public isImageGenerationModel = (modelName: string): boolean => modelName.includes('image-generation');
+  public isImageEditingModel = (modelName: string): boolean => modelName.includes('image-generation');
+  public isDocumentModel = (modelName: string): boolean => modelName.toLowerCase().includes('gemini-1.5');
+
+  private getDocumentType(url: string): string {
+    const lowerUrl = url.toLowerCase();
+    if (lowerUrl.startsWith('data:application/pdf') || lowerUrl.includes('.pdf')) return 'pdf';
+    if (lowerUrl.startsWith('data:text/plain') || lowerUrl.includes('.txt')) return 'txt';
+    if (lowerUrl.startsWith('data:text/markdown') || lowerUrl.includes('.md')) return 'md';
+    return 'unknown';
+  }
 
-  // ... 省略 extractDocumentData, extractImageData 等辅助函数，它们保持不变 ...
-  private getDocumentType(url: string): string { /* ... 保持不变 ... */ return ''; }
-  private extractDocumentData(documentUrl: string): { mimeType: string; data: string; text?: string; docType: string } { /* ... 保持不变 ... */ return { mimeType: '', data: '', docType: ''}; }
-  private extractImageData(imageUrl: string): { mimeType: string; data: string } { /* ... 保持不变 ... */ return {mimeType: '', data: ''}; }
+  private extractDocumentData(documentUrl: string): { mimeType: string; data: string; text?: string; docType: string } {
+    const docType = this.getDocumentType(documentUrl);
+    if (!documentUrl.startsWith("data:")) throw new Error("Document must be a base64 data URL.");
+    const [mimeInfo, base64Data] = documentUrl.split(",");
+    if (base64Data.length * 0.75 > MAX_DOCUMENT_SIZE_BYTES) throw new Error(`Document size exceeds ${MAX_DOCUMENT_SIZE_MB}MB.`);
+    const mimeType = mimeInfo.split(":")[1]?.split(";")[0] || 'application/octet-stream';
+    if (docType === 'txt' || docType === 'md') {
+      return { mimeType, data: base64Data, text: atob(base64Data), docType };
+    }
+    return { mimeType: docType === 'pdf' ? 'application/pdf' : mimeType, data: base64Data, docType };
+  }
+  
+  private extractImageData(imageUrl: string): { mimeType: string; data: string } {
+    if (imageUrl.startsWith("data:image/")) {
+      const [mimeInfo, base64Data] = imageUrl.split(",");
+      return { mimeType: mimeInfo.split(":")[1].split(";")[0], data: base64Data };
+    } else if (imageUrl.startsWith("http")) {
+      throw new Error("URL images are not supported. Please use base64 data URLs.");
+    }
+    return { mimeType: "image/jpeg", data: imageUrl };
+  }
 
+  private buildGoogleContent(messages: OpenAIMessage[]) {
+    return messages.map(msg => {
+      const role = msg.role === "assistant" ? "model" : "user";
+      if (typeof msg.content === "string") {
+        return { role, parts: [{ text: msg.content }] };
+      }
+      const parts = msg.content.map(part => {
+        if (part.type === "text") return { text: part.text };
+        if (part.type === "image_url" && part.image_url) {
+          const { mimeType, data } = this.extractImageData(part.image_url.url);
+          return { inlineData: { mimeType, data } };
+        }
+        if (part.type === "document" && part.document) {
+          const docData = this.extractDocumentData(part.document.url);
+          if (docData.docType === 'txt' || docData.docType === 'md') {
+            return { text: `${docData.docType === 'md' ? 'Markdown' : 'Text'} document content:\n${docData.text}` };
+          }
+          if (docData.docType === 'pdf') {
+            return { inlineData: { mimeType: docData.mimeType, data: docData.data } };
+          }
+        }
+        return { text: "" };
+      });
+      return { role, parts: parts.filter(p => p && (p.text || p.inlineData)) };
+    });
+  }
 
-  // --- 内容生成函数 (非流式) ---
-  // ... generateContentWithDocument, generateContent 等保持不变 ...
-  async generateContentWithDocument(messages: OpenAIMessage[], modelName: string): Promise<string> { /* ... 保持不变 ... */ return ''; }
-  async generateContent(messages: OpenAIMessage[], modelName: string, enableSearch: boolean = false): Promise<string> { /* ... 保持不变 ... */
-    // 这部分逻辑保持原样，用于非流式请求
+  async generateContent(messages: OpenAIMessage[], modelName: string): Promise<string> {
     const apiKey = this.getNextApiKey();
     const fullModelName = modelName.startsWith('models/') ? modelName : `models/${modelName}`;
-    const contents = messages.map(msg => {
-      // ... 消息转换逻辑 ...
-    });
-    const requestBody: any = { contents, generationConfig: { /*...*/ } };
-    const response = await fetch(
-      `https://generativelanguage.googleapis.com/v1beta/${fullModelName}:generateContent?key=${apiKey}`,
-      { method: "POST", body: JSON.stringify(requestBody), headers: { "Content-Type": "application/json" } }
-    );
-    // ... 错误处理和结果解析 ...
+    const contents = this.buildGoogleContent(messages);
+    const requestBody = { contents, generationConfig: { temperature: 0.7, maxOutputTokens: 8192 } };
+
+    const response = await fetch(`https://generativelanguage.googleapis.com/v1beta/${fullModelName}:generateContent?key=${apiKey}`,
+        { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify(requestBody) });
+
+    if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`Google AI API error: ${response.status} - ${errorText}`);
+    }
     const data = await response.json();
-    return data.candidates?.[0]?.content?.parts[0]?.text || "No response generated";
+    if (data.promptFeedback?.blockReason) {
+        throw new Error(`Request blocked by Google. Reason: ${data.promptFeedback.blockReason}`);
+    }
+    const candidate = data.candidates?.[0];
+    if (!candidate) throw new Error("No response generated from Google AI.");
+    if (candidate.finishReason === "SAFETY") throw new Error("Response blocked for safety reasons.");
+    return candidate.content?.parts?.[0]?.text || "No text response generated.";
   }
 
-
-  // --- [新增] 真正的流式内容生成函数 ---
   /**
-   * 使用 Google 的 streamGenerateContent 端点进行真正的流式内容生成。
-   * 这个函数是一个异步生成器，会不断 yield 从 API 收到的文本块。
-   * @param messages OpenAI 格式的消息
-   * @param modelName 请求的模型名称
-   * @yields {string} 文本块
+   * [新增] 真正的流式内容生成函数
+   * 使用 Google 的 streamGenerateContent 端点进行流式响应处理
    */
   async * streamGenerateContent(messages: OpenAIMessage[], modelName: string): AsyncGenerator<string> {
     const apiKey = this.getNextApiKey();
     const fullModelName = modelName.startsWith('models/') ? modelName : `models/${modelName}`;
+    const contents = this.buildGoogleContent(messages);
+    const requestBody = { contents, generationConfig: { temperature: 0.7, maxOutputTokens: 8192 } };
 
-    // 注意：文档/图片处理的逻辑需要与非流式版本保持一致
-    const contents = messages.map(msg => {
-        if (typeof msg.content === "string") {
-          return { role: msg.role === "assistant" ? "model" : "user", parts: [{ text: msg.content }] };
-        } else {
-          const messageParts = msg.content.map(part => {
-            if (part.type === "text") return { text: part.text };
-            if (part.type === "image_url" && part.image_url) {
-              const { mimeType, data } = this.extractImageData(part.image_url.url);
-              return { inlineData: { mimeType, data } };
-            }
-            // 简单处理，可以根据需要扩展
-            return { text: "" };
-          });
-          return { role: msg.role === "assistant" ? "model" : "user", parts: messageParts.filter(p => p.text || p.inlineData) };
-        }
-    });
-
-    const requestBody = {
-      contents,
-      generationConfig: { temperature: 0.7, maxOutputTokens: 8192 }
-    };
-    
     // [关键] 使用 :streamGenerateContent 端点
-    const response = await fetch(
-      `https://generativelanguage.googleapis.com/v1beta/${fullModelName}:streamGenerateContent?key=${apiKey}`,
-      {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify(requestBody),
-      }
-    );
+    const response = await fetch(`https://generativelanguage.googleapis.com/v1beta/${fullModelName}:streamGenerateContent?key=${apiKey}`,
+        { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify(requestBody) });
 
     if (!response.ok || !response.body) {
       const errorText = await response.text();
-      throw new Error(`Google AI API streaming error: ${response.status} - ${errorText}`);
+      throw new Error(`Google AI streaming API error: ${response.status} - ${errorText}`);
     }
-
-    // [关键] 读取并解析流式响应
+    
+    // [关键] 读取并解析流
     const reader = response.body.getReader();
     const decoder = new TextDecoder();
     let buffer = "";
@@ -256,25 +246,21 @@ class GoogleAIService {
       
       buffer += decoder.decode(value, { stream: true });
       
-      // Google 的流式响应可能会在一个数据包里包含多个JSON对象，它们以 "data: " 开头
-      // 我们需要处理这种情况
-      while (buffer.includes('\n')) {
-          const endOfLine = buffer.indexOf('\n');
-          const line = buffer.substring(0, endOfLine).trim();
-          buffer = buffer.substring(endOfLine + 1);
+      // Google 的流式响应可能在一个数据包里包含多个以 "data: " 开头的 JSON 对象
+      const lines = buffer.split('\n');
+      buffer = lines.pop() || ''; // Keep the last, possibly incomplete, line in buffer
 
+      for (const line of lines) {
           if (line.startsWith('data: ')) {
               try {
-                  const jsonStr = line.substring(6); // 去掉 'data: '
+                  const jsonStr = line.substring(6);
                   const chunk = JSON.parse(jsonStr);
                   
-                  if (chunk.error) {
-                      throw new Error(`Google API Error in stream: ${chunk.error.message}`);
-                  }
+                  if (chunk.error) throw new Error(`Google API stream error: ${chunk.error.message}`);
 
                   const text = chunk.candidates?.[0]?.content?.parts?.[0]?.text;
                   if (text) {
-                      yield text;
+                      yield text; // 产生一个文本块
                   }
               } catch (e) {
                   console.warn("Could not parse stream chunk:", line, e.message);
@@ -284,13 +270,44 @@ class GoogleAIService {
     }
   }
 
-  // ... 其他辅助函数如 generateOrEditImage, generateContentWithGrounding 保持不变 ...
-  async generateOrEditImageWithGemini(prompt: string, modelName: string = "gemini-2.0-flash-preview-image-generation", inputImage?: { mimeType: string; data: string }): Promise<{ text?: string; imageBase64?: string; imageUrl?: string }> { /* ... */ return {};}
-  async generateContentWithGrounding(messages: OpenAIMessage[], modelName: string): Promise<string> { /* ... */ return ''; }
-  async generateContentWithSearchPrompt(messages: OpenAIMessage[], modelName: string): Promise<string> { /* ... */ return ''; }
-  async generateOrEditImage(prompt: string, modelName: string, inputImages?: any[]): Promise<string> { /* ... */ return ''; }
-}
+  async generateOrEditImage(prompt: string, modelName: string, inputImages?: any[]): Promise<string> {
+    const apiKey = this.getNextApiKey();
+    const fullModelName = modelName.startsWith('models/') ? modelName : `models/${modelName}`;
+    const requestParts: any[] = [{ text: prompt }];
+    let inputImage;
+    if (inputImages && inputImages.length > 0) {
+        inputImage = this.extractImageData(inputImages[0].url);
+        requestParts.push({ inline_data: { mime_type: inputImage.mimeType, data: inputImage.data } });
+    }
+
+    const requestBody = {
+      contents: [{ parts: requestParts }],
+      generationConfig: { responseModalities: ["TEXT", "IMAGE"], temperature: 0.7 }
+    };
+    const response = await fetch(`https://generativelanguage.googleapis.com/v1beta/${fullModelName}:generateContent?key=${apiKey}`,
+        { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify(requestBody) });
+
+    if (!response.ok) throw new Error(`Image processing failed: ${response.status} - ${await response.text()}`);
+    const data = await response.json();
+    const candidate = data.candidates?.[0];
+    if (!candidate) throw new Error("No image response from Google.");
+    if (candidate.finishReason === "SAFETY") throw new Error("Image request blocked for safety reasons.");
+
+    let textResponse = "";
+    let imageBase64 = "";
+    (candidate.content?.parts || []).forEach((part: any) => {
+        if (part.text) textResponse += part.text;
+        if (part.inlineData?.data || part.inline_data?.data) {
+            imageBase64 = part.inlineData?.data || part.inline_data.data;
+        }
+    });
 
+    let result = "";
+    if (textResponse) result += textResponse + "\\\\n\\\\n";
+    if (imageBase64) result += `${inputImage ? 'Edited' : 'Generated'} image:\\\\n"data:image/png;base64,${imageBase64}"`;
+    return result || "Image processing complete.";
+  }
+}
 
 class OpenAICompatibleServer {
   private googleAI: GoogleAIService;
@@ -301,91 +318,77 @@ class OpenAICompatibleServer {
     this.authKey = Deno.env.get("AUTH_KEY") || "";
   }
 
-  private authenticate(request: Request): boolean { /* ... 保持不变 ... */ return true; }
-  private isDocumentContent(url?: string): boolean { /* ... 保持不变 ... */ return false; }
-  private async handleAudioSpeech(request: Request): Promise<Response> { /* ... 保持不变 ... */ return new Response(); }
+  private authenticate(request: Request): boolean {
+    if (!this.authKey) return true;
+    return request.headers.get("Authorization")?.replace("Bearer ", "") === this.authKey;
+  }
 
+  private isDocumentContent(url?: string): boolean {
+    if (!url) return false;
+    const lowerUrl = url.toLowerCase();
+    return lowerUrl.includes('.pdf') || lowerUrl.startsWith('data:application/pdf') ||
+           lowerUrl.includes('.txt') || lowerUrl.startsWith('data:text/plain') ||
+           lowerUrl.includes('.md') || lowerUrl.startsWith('data:text/markdown');
+  }
+
+  private async handleAudioSpeech(request: Request): Promise<Response> {
+    const body: OpenAITTSRequest = await request.json();
+    if (!body.input || !body.voice || !body.model) {
+        return new Response(JSON.stringify({ error: "Missing required fields: input, voice, model." }), { status: 400 });
+    }
+    const audioBuffer = await this.googleAI.generateSpeech(body.input, body.model, body.voice);
+    return new Response(audioBuffer, { headers: { "Content-Type": "audio/mpeg" } });
+  }
+  
   private async handleChatCompletions(request: Request): Promise<Response> {
     try {
       const body: OpenAIRequest = await request.json();
       const requestedModel = body.model || "gemini-1.5-pro";
-      const stream = body.stream || false;
-      console.log(`Request for model: ${requestedModel}, stream: ${stream}`);
 
-      if (stream) {
-        // [修改] 调用新的流式处理逻辑
+      // [修改] 流式请求处理
+      if (body.stream) {
         const googleStream = this.googleAI.streamGenerateContent(body.messages, requestedModel);
         const openAIStream = this.streamGoogleResponseAsOpenAI(googleStream, requestedModel);
         return new Response(openAIStream, {
-          headers: { "Content-Type": "text/event-stream", "Cache-Control": "no-cache", "Connection": "keep-alive", "Access-Control-Allow-Origin": "*" }
+          headers: { "Content-Type": "text/event-stream", "Cache-Control": "no-cache", "Connection": "keep-alive" }
         });
-      } else {
-        // [保持不变] 非流式逻辑
-        const lastMessage = body.messages[body.messages.length - 1];
-        const content = typeof lastMessage.content === "string"
-          ? lastMessage.content
-          : (Array.isArray(lastMessage.content) ? lastMessage.content.map(p => p.text || "").join(" ") : "");
-
-        const hasDocument = body.messages.some(msg =>
-          Array.isArray(msg.content) &&
-          msg.content.some(part => part.type === "document" || this.isDocumentContent(part.document?.url))
-        );
-
-        const hasImages = body.messages.some(msg => Array.isArray(msg.content) && msg.content.some(part => part.type === "image_url"));
-        
-        let inputImages: any[] = [];
-        if (hasImages) {
-            body.messages.forEach(msg => {
-            if (Array.isArray(msg.content)) {
-                msg.content.forEach(part => {
-                if (part.type === "image_url" && part.image_url) inputImages.push({ url: part.image_url.url });
-                });
-            }
-            });
-        }
-      
-        let responseText: string;
-
-        if (hasDocument) {
-          responseText = await this.googleAI.generateContentWithDocument(body.messages, requestedModel);
-        } else if (this.googleAI.isImageEditingModel(requestedModel) && hasImages) {
-          responseText = await this.googleAI.generateOrEditImage(content, requestedModel, inputImages);
-        } else if (this.googleAI.isImageGenerationModel(requestedModel)) {
-          responseText = await this.googleAI.generateOrEditImage(content, requestedModel);
-        } else if (content.toLowerCase().startsWith("/search:")) {
-          const query = content.substring(8).trim();
-          const searchMessages = [{ ...lastMessage, content: query }];
-          responseText = await this.googleAI.generateContentWithGrounding(searchMessages, requestedModel);
-        } else {
-          responseText = await this.googleAI.generateContent(body.messages, requestedModel, false);
-        }
-        
-        const responsePayload = {
-            id: `chatcmpl-${Date.now()}`, object: "chat.completion", created: Math.floor(Date.now() / 1000), model: requestedModel,
-            choices: [{ index: 0, message: { role: "assistant", content: responseText }, finish_reason: "stop" }],
-            usage: { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 }
-        };
-        return new Response(JSON.stringify(responsePayload), { headers: { "Content-Type": "application/json" } });
       }
+
+      // [保持不变] 非流式请求处理
+      const lastMessage = body.messages[body.messages.length - 1];
+      const content = typeof lastMessage.content === "string" ? lastMessage.content : (Array.isArray(lastMessage.content) ? lastMessage.content.map(p => p.text || "").join(" ") : "");
+      const hasDocument = body.messages.some(msg => Array.isArray(msg.content) && msg.content.some(part => part.type === "document" || this.isDocumentContent(part.document?.url)));
+      const hasImages = body.messages.some(msg => Array.isArray(msg.content) && msg.content.some(part => part.type === "image_url"));
+
+      let responseText: string;
+      if (this.googleAI.isImageGenerationModel(requestedModel)) {
+        const inputImages = hasImages ? body.messages.flatMap(msg => Array.isArray(msg.content) ? msg.content.filter(p => p.type === 'image_url' && p.image_url).map(p => ({ url: p.image_url!.url })) : []) : undefined;
+        responseText = await this.googleAI.generateOrEditImage(content, requestedModel, inputImages);
+      } else if(hasDocument || hasImages) { // Vision/Document models
+        responseText = await this.googleAI.generateContent(body.messages, requestedModel);
+      } else { // Standard text
+        responseText = await this.googleAI.generateContent(body.messages, requestedModel);
+      }
+
+      const responsePayload = {
+        id: `chatcmpl-${Date.now()}`, object: "chat.completion", created: Math.floor(Date.now() / 1000), model: requestedModel,
+        choices: [{ index: 0, message: { role: "assistant", content: responseText }, finish_reason: "stop" }],
+        usage: { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 }
+      };
+      return new Response(JSON.stringify(responsePayload), { headers: { "Content-Type": "application/json" } });
+
     } catch (error) {
-        console.error("Error in chat completions:", error.message);
-        const status = error.message.includes("exceeds the limit") || error.message.includes("Invalid") ? 400 : 500;
-        return new Response(
-            JSON.stringify({
-            error: {
-                message: error.message,
-                type: status === 400 ? "invalid_request_error" : "api_error",
-                code: null
-            }
-            }),
-            { status, headers: { "Content-Type": "application/json" } }
-        );
+      console.error("Error in chat completions:", error.message);
+      const status = error.message.includes("exceeds") || error.message.includes("Invalid") ? 400 : 500;
+      return new Response(JSON.stringify({ error: { message: error.message, type: "api_error" } }),
+        { status, headers: { "Content-Type": "application/json" } });
     }
   }
   
-  // [删除] 旧的伪流式函数 streamStringAsOpenAIResponse
-  
-  // [新增] 真正的流式响应转换函数
+  /**
+   * [新增] 真正的流式响应转换函数
+   * 将 Google 的数据流转换为 OpenAI 兼容的 Server-Sent Events 流
+   */
   private streamGoogleResponseAsOpenAI(googleStream: AsyncGenerator<string>, modelName: string): ReadableStream<Uint8Array> {
     const encoder = new TextEncoder();
     const streamId = `chatcmpl-${Date.now()}`;
@@ -393,29 +396,22 @@ class OpenAICompatibleServer {
 
     return new ReadableStream({
       async start(controller) {
-        // 首先发送一个空的 assistant role 块，这是 OpenAI 的惯例
+        // 发送第一个包含角色的数据块
         const initialChunk = { id: streamId, object: 'chat.completion.chunk', created: creationTime, model: modelName, choices: [{ index: 0, delta: { role: 'assistant', content: '' }, finish_reason: null }] };
         controller.enqueue(encoder.encode(`data: ${JSON.stringify(initialChunk)}\n\n`));
         
-        // 迭代从 Google API 收到的文本块
+        // 迭代从 Google API 收到的文本块并转发
         for await (const textChunk of googleStream) {
             if (textChunk) {
                 const chunk = {
-                    id: streamId,
-                    object: 'chat.completion.chunk',
-                    created: creationTime,
-                    model: modelName,
-                    choices: [{
-                        index: 0,
-                        delta: { content: textChunk }, // 将收到的文本块放入 delta.content
-                        finish_reason: null
-                    }]
+                    id: streamId, object: 'chat.completion.chunk', created: creationTime, model: modelName,
+                    choices: [{ index: 0, delta: { content: textChunk }, finish_reason: null }]
                 };
                 controller.enqueue(encoder.encode(`data: ${JSON.stringify(chunk)}\n\n`));
             }
         }
         
-        // 所有数据块发送完毕后，发送结束信号
+        // 发送结束信号
         const finalChunk = { id: streamId, object: 'chat.completion.chunk', created: creationTime, model: modelName, choices: [{ index: 0, delta: {}, finish_reason: 'stop' }] };
         controller.enqueue(encoder.encode(`data: ${JSON.stringify(finalChunk)}\n\n`));
         controller.enqueue(encoder.encode('data: [DONE]\n\n'));
@@ -424,8 +420,31 @@ class OpenAICompatibleServer {
     });
   }
   
-  private async handleModels(): Promise<Response> { /* ... 保持不变 ... */ return new Response(); }
-  private async handleStatus(): Promise<Response> { /* ... 保持不变 ... */ return new Response(); }
+  private async handleModels(): Promise<Response> {
+    const googleModels = await this.googleAI.fetchOfficialModels();
+    const fallbackModels = this.googleAI['getFallbackModels']();
+    
+    const uniqueModelMap = new Map();
+    [...googleModels, ...fallbackModels].forEach(model => {
+        const modelId = model.id || model.name.replace('models/', '');
+        if (!uniqueModelMap.has(modelId)) {
+            uniqueModelMap.set(modelId, {
+                id: modelId, object: "model", created: Math.floor(Date.now() / 1000), owned_by: "google"
+            });
+        }
+    });
+    return new Response(JSON.stringify({ object: "list", data: Array.from(uniqueModelMap.values()) }), { headers: { "Content-Type": "application/json" } });
+  }
+  
+  private async handleStatus(): Promise<Response> {
+      const status = {
+          status: "healthy", timestamp: new Date().toISOString(), version: "2.5.1",
+          api_keys_loaded: this.googleAI.apiKeys.length,
+          models_in_cache: this.googleAI.cachedModels.length,
+          models_last_fetched: this.googleAI.modelsLastFetch > 0 ? new Date(this.googleAI.modelsLastFetch).toISOString() : "never"
+      };
+      return new Response(JSON.stringify(status), { headers: { "Content-Type": "application/json" } });
+  }
 
   async handleRequest(request: Request): Promise<Response> {
     const corsHeaders = {
@@ -441,19 +460,23 @@ class OpenAICompatibleServer {
     const url = new URL(request.url);
     let response: Response;
 
-    // 路由处理
-    if (url.pathname === "/health" || url.pathname === "/status") {
-      response = await this.handleStatus();
-    } else if (!this.authenticate(request)) {
-      response = new Response(JSON.stringify({ error: { message: "Unauthorized" } }), { status: 401 });
-    } else if (url.pathname === "/v1/audio/speech" && request.method === "POST") {
-      response = await this.handleAudioSpeech(request);
-    } else if (url.pathname === "/v1/chat/completions" && request.method === "POST") {
-      response = await this.handleChatCompletions(request);
-    } else if (url.pathname === "/v1/models" && request.method === "GET") {
-      response = await this.handleModels();
-    } else {
-      response = new Response("Not Found", { status: 404 });
+    try {
+        if (url.pathname === "/health" || url.pathname === "/status") {
+          response = await this.handleStatus();
+        } else if (!this.authenticate(request)) {
+          response = new Response(JSON.stringify({ error: { message: "Unauthorized" } }), { status: 401 });
+        } else if (url.pathname === "/v1/audio/speech" && request.method === "POST") {
+          response = await this.handleAudioSpeech(request);
+        } else if (url.pathname === "/v1/chat/completions" && request.method === "POST") {
+          response = await this.handleChatCompletions(request);
+        } else if (url.pathname === "/v1/models" && request.method === "GET") {
+          response = await this.handleModels();
+        } else {
+          response = new Response("Not Found", { status: 404 });
+        }
+    } catch (error) {
+        console.error("Unhandled error:", error);
+        response = new Response(JSON.stringify({ error: { message: error.message || "An internal server error occurred." } }), { status: 500 });
     }
 
     // 为所有响应添加CORS头
@@ -461,32 +484,29 @@ class OpenAICompatibleServer {
     for (const [key, value] of Object.entries(corsHeaders)) {
       finalHeaders.set(key, value);
     }
-
-    return new Response(response.body, { status: response.status, headers: finalHeaders });
+    return new Response(response.body, { status: response.status, statusText: response.statusText, headers: finalHeaders });
   }
 }
 
 // --- 服务器启动 ---
 const server = new OpenAICompatibleServer();
 
-console.log("🚀 OpenAI Compatible Server with Google AI starting on port 8000...");
+console.log("🚀 OpenAI Compatible Server with Google AI starting...");
 console.log(`✅ Loaded ${server['googleAI'].apiKeys.length} API key(s).`);
-console.log(`📄 Max document size set to ${MAX_DOCUMENT_SIZE_MB}MB.`);
 
-// 启动时预取模型
-server['googleAI'].fetchOfficialModels().then(models => {
-  console.log(`✅ Successfully fetched ${models.length} models from Google AI.`);
-}).catch(error => {
-  console.warn(`⚠️ Could not pre-fetch models: ${error.message}. Will use fallbacks or fetch on first request.`);
+server['googleAI'].fetchOfficialModels().catch(error => {
+  console.warn(`⚠️ Could not pre-fetch models: ${error.message}. Will use fallbacks.`);
 });
 
+const port = 7860;
+console.log(`Server listening on http://localhost:${port}`);
 console.log("\n🔗 Endpoints:");
-console.log("   POST /v1/chat/completions");
-console.log("   POST /v1/audio/speech");
-console.log("   GET  /v1/models");
-console.log("   GET  /status");
+console.log(`   POST /v1/chat/completions`);
+console.log(`   POST /v1/audio/speech`);
+console.log(`   GET  /v1/models`);
+console.log(`   GET  /status`);
 
 await serve(
   (request: Request) => server.handleRequest(request),
-  { port: 7860 }
+  { port： 7860 }
 );