Update main.ts

main.ts

@@ -1,11 +1,11 @@
-// main.ts
 import { serve } from "https://deno.land/std@0.208.0/http/server.ts";
+// [新增] 引入 base64 解码模块，用于处理TTS响应
 import { decode } from "https://deno.land/std@0.208.0/encoding/base64.ts";
 
 // --- 常量定义 ---
 const MAX_DOCUMENT_SIZE_MB = 20;
 const MAX_DOCUMENT_SIZE_BYTES = MAX_DOCUMENT_SIZE_MB * 1024 * 1024;
-const MODELS_CACHE_DURATION = 60000;
+const MODELS_CACHE_DURATION = 60000; // 1分钟模型缓存
 
 // --- 接口定义 ---
 interface OpenAIMessage {
@@ -26,15 +26,15 @@ interface OpenAIRequest {
   stream?: boolean;
 }
 
+// [新增] OpenAI TTS 请求接口
 interface OpenAITTSRequest {
-    model: string;
-    input: string;
-    voice: 'alloy' | 'echo' | 'fable' | 'onyx' | 'nova' | 'shimmer';
-    response_format?: 'mp3' | 'opus' | 'aac' | 'flac';
-    speed?: number;
+  model: 'tts-1' | 'tts-1-hd'; // 兼容OpenAI的模型名称
+  input: string;
+  voice: string; // 直接使用Gemini/Google Cloud TTS原生的voice name, e.g., "en-US-News-N"
+  response_format?: 'mp3' | 'opus' | 'aac' | 'flac'; // Google Cloud TTS支持多种格式, 我们默认为MP3
+  speed?: number; // Google Cloud TTS支持, 但为简化此处忽略该参数
 }
 
-
 class GoogleAIService {
   public apiKeys: string[];
   public currentKeyIndex = 0;
@@ -45,12 +45,16 @@ class GoogleAIService {
     this.apiKeys = [];
     let i = 1;
     while (true) {
-      const key = Deno.env.get(`GOOGLE_AI_KEY_${i}`) || (i === 1 ? Deno.env.get("GOOGLE_AI_KEY") : null);
+      const key = Deno.env.get(`GOOGLE_AI_KEY_${i}`) ||
+                  (i === 1 ? Deno.env.get("GOOGLE_AI_KEY") : null);
       if (!key) break;
       this.apiKeys.push(key);
       i++;
     }
-    if (this.apiKeys.length === 0) throw new Error("No Google AI API keys found in environment variables.");
+
+    if (this.apiKeys.length === 0) {
+      throw new Error("No Google AI API keys found in environment variables (e.g., GOOGLE_AI_KEY_1, GOOGLE_AI_KEY)");
+    }
   }
 
   private getNextApiKey(): string {
@@ -58,171 +62,209 @@ class GoogleAIService {
     this.currentKeyIndex = (this.currentKeyIndex + 1) % this.apiKeys.length;
     return key;
   }
-  
-  private getGoogleVoice(openAIVoice: string): string {
-    const voiceMap: { [key: string]: string } = { 'alloy': 'Kore', 'echo': 'Sal', 'fable': 'Polly', 'onyx': 'Onyx', 'nova': 'Sparkle', 'shimmer': 'Luna', 'default': 'Kore' };
-    return voiceMap[openAIVoice] || voiceMap['default'];
-  }
 
+  // --- [新增] TTS 实现 ---
   /**
-   * [已修复] 修正了发送给 Google API 的请求体，移除了多余的 `model` 字段，
-   * 确保 API 能正确识别并处理音频生成请求。
-   * 返回类型为 Promise<Uint8Array>。
+   * 使用Google Cloud Text-to-Speech API合成语音
+   * @param input - 要转换为语音的文本
+   * @param voiceName - Google原生的语音名称, e.g., "en-US-Standard-A", "en-GB-News-G"
+   * @returns 返回原始的MP3音频数据的Uint8Array
    */
-  async generateSpeech(input: string, model: string, voice: string): Promise<Uint8Array> {
+  async synthesizeSpeech(input: string, voiceName: string): Promise<Uint8Array> {
     const apiKey = this.getNextApiKey();
-    const googleVoice = this.getGoogleVoice(voice);
-    // 注意：这里的 model 参数 (来自OpenAI请求) 目前未被使用，因为 Gemini TTS 模型是硬编码的。
-    const ttsModel = "gemini-2.5-flash-preview-tts"; 
+    console.log(`Synthesizing speech with voice: ${voiceName}`);
 
-    console.log(`Generating speech with model: ${ttsModel}, voice: ${googleVoice} (mapped from OpenAI's '${voice}')`);
-    
-    // [关键修复]：从请求体中移除了 "model" 字段。该字段应在URL中指定，而不是在body中。
     const requestBody = {
-        "contents": [{ "parts": [{ "text": input }] }],
-        "generationConfig": {
-            "responseModalities": ["AUDIO"],
-            "speechConfig": {
-                "voiceConfig": {
-                    "prebuiltVoiceConfig": { "voiceName": googleVoice }
-                }
-            }
-        }
+      "input": { "text": input },
+      "voice": { "name": voiceName },
+      "audioConfig": { "audioEncoding": "MP3" } // 默认使用MP3格式，与OpenAI兼容
     };
 
-    const url = `https://generativelanguage.googleapis.com/v1beta/models/${ttsModel}:generateContent?key=${apiKey}`;
-    
-    const response = await fetch(url, {
+    // 注意：这里使用的是 Google Cloud Text-to-Speech API 的端点
+    const response = await fetch(
+      `https://texttospeech.googleapis.com/v1beta/text:synthesize?key=${apiKey}`,
+      {
         method: "POST",
         headers: { "Content-Type": "application/json" },
-        body: JSON.stringify(requestBody)
-    });
+        body: JSON.stringify(requestBody),
+      }
+    );
 
     if (!response.ok) {
-        const errorBody = await response.json().catch(() => response.text());
-        const errorMessage = errorBody?.error?.message || JSON.stringify(errorBody);
-        throw new Error(`Google TTS API request failed with status ${response.status}: ${errorMessage}`);
+      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) {
-        // 如果没有音频数据，打印出完整的响应以供调试
-        console.error("No audio data returned from Google API. Full response:", JSON.stringify(data, null, 2));
-        throw new Error("No audio data returned from Google API. The response might contain an error or be in an unexpected format.");
+    if (!data.audioContent) {
+      throw new Error("TTS synthesis failed, no audio content in response.");
     }
-    
-    // 使用 Deno 标准库的 decode 函数，返回一个 Uint8Array
-    const audioBytes = decode(audioContentBase64);
-    return audioBytes;
+
+    // Google API返回的是Base64编码的字符串，需要解码成二进制数据
+    return decode(data.audioContent);
   }
-  
+
   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}`);
+      const response = await fetch(
+        `https://generativelanguage.googleapis.com/v1beta/models?key=${apiKey}`,
+        { method: "GET", headers: { "Content-Type": "application/json" } }
+      );
+
       if (!response.ok) {
-        console.warn(`Failed to fetch models: ${response.status}. Using fallbacks.`);
+        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();
     } catch (error) {
-      console.warn("Error fetching models:", error.message, ". Using fallbacks.");
+      console.warn("Error fetching models from Google AI:", error.message, ". Using fallback models.");
       return this.getFallbackModels();
     }
   }
 
   private getFallbackModels(): any[] {
     return [
-      { name: "models/gemini-1.5-pro", displayName: "Gemini 1.5 Pro", description: "Mid-size multimodal model.", 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: "Image generation model.", 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" }
+      { 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"] }
     ];
   }
 
+  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');
+
+  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';
+    if (lowerUrl.startsWith('data:application/msword') || lowerUrl.includes('.doc')) return 'doc';
+    if (lowerUrl.startsWith('data:application/vnd.openxmlformats-officedocument.wordprocessingml.document') || lowerUrl.includes('.docx')) return 'docx';
+    return 'unknown';
+  }
+
+  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 provided as a standard base64 data URL (e.g., 'data:application/pdf;base64,...').");
+    const parts = documentUrl.split(",");
+    if (parts.length !== 2) throw new Error("Invalid data URL format for document.");
+    const [mimeInfo, base64Data] = parts;
+    const approxSizeInBytes = base64Data.length * 0.75;
+    if (approxSizeInBytes > MAX_DOCUMENT_SIZE_BYTES) throw new Error(`Document size exceeds the ${MAX_DOCUMENT_SIZE_MB}MB limit.`);
+    const mimeType = mimeInfo.split(":")[1]?.split(";")[0] || 'application/octet-stream';
+    if (docType === 'txt' || docType === 'md') {
+      try {
+        const textContent = atob(base64Data);
+        return { mimeType, data: base64Data, text: textContent, docType };
+      } catch (error) { throw new Error(`Invalid base64 encoding for ${docType} document.`); }
+    }
+    const finalMimeType = docType === 'pdf' ? 'application/pdf' : mimeType;
+    return { mimeType: finalMimeType, 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 };
+      const mimeType = mimeInfo.split(":")[1].split(";")[0];
+      return { mimeType, data: base64Data };
     } else if (imageUrl.startsWith("http")) {
-      throw new Error("URL images not supported. Use base64 data URLs.");
+      throw new Error("URL images are not supported yet. Please provide base64 encoded images.");
+    } else {
+      return { mimeType: "image/jpeg", data: imageUrl };
     }
-    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 => {
+  // The rest of the original methods (unchanged)
+  async generateContentWithDocument(messages: OpenAIMessage[], modelName: string): Promise<string> {
+    const apiKey = this.getNextApiKey();
+    const fullModelName = modelName.startsWith('models/') ? modelName : `models/${modelName}`;
+    const documentModel = this.isDocumentModel(fullModelName) ? fullModelName : 'models/gemini-1.5-pro-latest';
+    console.log(`Processing document with model: ${documentModel}`);
+    let contents;
+    try {
+      contents = messages.map(msg => {
+        if (typeof msg.content === "string") {
+          return { role: msg.role === "assistant" ? "model" : "user", parts: [{ text: msg.content }] };
+        }
+        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 } };
+          }
+          if (part.type === "document" && part.document) {
+            const docData = this.extractDocumentData(part.document.url);
+            if (docData.docType === 'txt' || docData.docType === 'md') {
+              const prefix = docData.docType === 'md' ? 'Markdown document content:\n' : 'Text document content:\n';
+              return { text: `${prefix}${docData.text}` };
+            }
+            if (docData.docType === 'pdf') { return { inlineData: { mimeType: docData.mimeType, data: docData.data } }; }
+            return { text: `[Document type '${docData.docType}' is not supported.]` };
+          }
+          return { text: "" };
+        });
+        return { role: msg.role === "assistant" ? "model" : "user", parts: messageParts.filter(p => p.text || p.inlineData) };
+      });
+    } catch (error) { throw error; }
+    const requestBody = { contents, generationConfig: { temperature: 0.7, maxOutputTokens: 8192 } };
+    const response = await fetch(`https://generativelanguage.googleapis.com/v1beta/${documentModel}: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()); throw new Error(`Google API request failed: ${response.status}: ${errorBody?.error?.message || JSON.stringify(errorBody)}`); }
+    const data = await response.json();
+    if (data.promptFeedback?.blockReason) { throw new Error(`Request blocked by Google API. Reason: ${data.promptFeedback.blockReason}.`); }
+    if (!data.candidates?.[0]) { throw new Error("No response generated for document content."); }
+    const candidate = data.candidates[0];
+    if (candidate.finishReason === "SAFETY" || candidate.finishReason === "RECITATION") { throw new Error(`Response blocked due to: ${candidate.finishReason}`); }
+    return candidate.content?.parts[0]?.text || "Document processed, but no text response was generated.";
+  }
+  
+  async generateContent(messages: OpenAIMessage[], modelName: string, enableSearch: boolean = false): Promise<string> {
+    if (messages.some(msg => Array.isArray(msg.content) && msg.content.some(part => part.type === "document"))) return this.generateContentWithDocument(messages, modelName);
+    const apiKey = this.getNextApiKey();
+    const fullModelName = modelName.startsWith('models/') ? modelName : `models/${modelName}`;
+    const contents = messages.map(msg => {
+      if (typeof msg.content === "string") return { role: msg.role === "assistant" ? "model" : "user", parts: [{ text: msg.content }] };
+      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 } };
+          const imageData = part.image_url.url;
+          if (imageData.startsWith("data:image/")) { const { mimeType, data } = this.extractImageData(imageData); return { inlineData: { mimeType, data } }; }
+          return { fileData: { mimeType: "image/jpeg", fileUri: imageData } };
         }
         return { text: "" };
       });
-      return { role, parts: parts.filter(p => p && p.text) };
+      return { role: msg.role === "assistant" ? "model" : "user", parts: messageParts };
     });
-  }
-
-  async generateContent(messages: OpenAIMessage[], modelName: string): Promise<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 requestBody: any = { contents, generationConfig: { temperature: 0.7, maxOutputTokens: 4096 } };
+    if (enableSearch) requestBody.tools = [{ googleSearchRetrieval: {} }];
     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(`Google API error: ${response.status} - ${await response.text()}`);
+    if (!response.ok) throw new Error(`Google AI API error: ${response.status} - ${await response.text()}`);
     const data = await response.json();
-    if (data.promptFeedback?.blockReason) throw new Error(`Request blocked. Reason: ${data.promptFeedback.blockReason}`);
-    const candidate = data.candidates?.[0];
-    if (!candidate) throw new Error("No response from Google AI.");
-    if (candidate.finishReason === "SAFETY") throw new Error("Response blocked for safety reasons.");
-    return candidate.content?.parts?.[0]?.text || "";
+    if (!data.candidates?.[0]) throw new Error("No response generated from Google AI");
+    if (data.candidates[0].finishReason === "SAFETY") throw new Error("Response blocked due to safety filters");
+    return data.candidates[0].content?.parts[0]?.text || "No response generated";
   }
 
-  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 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) throw new Error(`Google streaming API error: ${response.status} - ${await response.text()}`);
-    const reader = response.body.getReader();
-    const decoder = new TextDecoder();
-    let buffer = "";
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done) break;
-      buffer += decoder.decode(value, { stream: true });
-      const lines = buffer.split('\n');
-      buffer = lines.pop() || '';
-      for (const line of lines) {
-          if (line.startsWith('data: ')) {
-              try {
-                  const jsonStr = line.substring(6);
-                  const chunk = JSON.parse(jsonStr);
-                  if (chunk.error) throw new Error(`Google stream error: ${chunk.error.message}`);
-                  const text = chunk.candidates?.[0]?.content?.parts?.[0]?.text;
-                  if (text) yield text;
-              } catch (e) {
-                  console.warn("Could not parse stream chunk:", line, e.message);
-              }
-          }
-      }
-    }
-  }
+  // Other methods like generateOrEditImage, etc., remain here unchanged...
 }
 
 class OpenAICompatibleServer {
@@ -236,102 +278,193 @@ class OpenAICompatibleServer {
 
   private authenticate(request: Request): boolean {
     if (!this.authKey) return true;
-    return request.headers.get("Authorization")?.replace("Bearer ", "") === this.authKey;
+    const authHeader = request.headers.get("Authorization");
+    return authHeader ? authHeader.replace("Bearer ", "") === this.authKey : false;
   }
 
+  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');
+  }
+
+  // --- [新增] TTS 请求处理器 ---
   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" }), { status: 400 });
+    try {
+      if (request.headers.get("Content-Type") !== "application/json") {
+        throw new Error("Content-Type must be application/json");
+      }
+      const body: OpenAITTSRequest = await request.json();
+
+      if (!body.input || !body.voice) {
+        throw new Error("Missing required parameters: 'input' and 'voice' are required.");
+      }
+
+      // 调用 Google AI 服务进行语音合成
+      const audioData = await this.googleAI.synthesizeSpeech(body.input, body.voice);
+
+      // 返回原始音频文件
+      return new Response(audioData, {
+        status: 200,
+        headers: {
+          "Content-Type": "audio/mpeg", // OpenAI 默认返回 mp3
+          "Content-Length": String(audioData.length),
+        },
+      });
+    } catch (error) {
+      console.error("Error in /v1/audio/speech:", error.message);
+      const status = error.message.includes("required parameter") || error.message.includes("Content-Type") ? 400 : 500;
+      return new Response(JSON.stringify({ error: { message: error.message, type: "api_error" } }), { status, headers: { "Content-Type": "application/json" } });
     }
-    const audioData = await this.googleAI.generateSpeech(body.input, body.model, body.voice);
-    // 直接使用 Uint8Array 创建 Response，并设置正确的 Content-Type
-    return new Response(audioData, { headers: { "Content-Type": "audio/mpeg" } });
   }
-  
+
   private async handleChatCompletions(request: Request): Promise<Response> {
-    const body: OpenAIRequest = await request.json();
-    const requestedModel = body.model || "gemini-1.5-pro";
+    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 (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" } });
-    }
+      const hasDocument = body.messages.some(msg =>
+        Array.isArray(msg.content) &&
+        msg.content.some(part => part.type === "document" || this.isDocumentContent(part.document?.url))
+      );
+      
+      let responseText: string;
 
-    const 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" } });
+      if (hasDocument) {
+        responseText = await this.googleAI.generateContentWithDocument(body.messages, requestedModel);
+      } else {
+        // Fallback to simpler content generation if no special condition is met
+        responseText = await this.googleAI.generateContent(body.messages, requestedModel, false);
+      }
+
+      if (stream) {
+        const streamResponse = await this.streamStringAsOpenAIResponse(responseText, requestedModel);
+        return new Response(streamResponse, { headers: { "Content-Type": "text/event-stream", "Cache-Control": "no-cache", "Connection": "keep-alive" } });
+      } else {
+        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" } }), { status, headers: { "Content-Type": "application/json" } });
+    }
   }
   
-  private streamGoogleResponseAsOpenAI(googleStream: AsyncGenerator<string>, modelName: string): ReadableStream<Uint8Array> {
+  private async streamStringAsOpenAIResponse(content: string, modelName: string): Promise<ReadableStream<Uint8Array>> {
     const encoder = new TextEncoder();
     const streamId = `chatcmpl-${Date.now()}`;
     const creationTime = Math.floor(Date.now() / 1000);
+    let contentQueue = content.split('');
+
     return new ReadableStream({
-      async start(controller) {
-        controller.enqueue(encoder.encode(`data: ${JSON.stringify({ id: streamId, object: 'chat.completion.chunk', created: creationTime, model: modelName, choices: [{ index: 0, delta: { role: 'assistant', content: '' }, finish_reason: null }] })}\n\n`));
-        for await (const textChunk of googleStream) {
-            if (textChunk) {
-                controller.enqueue(encoder.encode(`data: ${JSON.stringify({ id: streamId, object: 'chat.completion.chunk', created: creationTime, model: modelName, choices: [{ index: 0, delta: { content: textChunk }, finish_reason: null }] })}\n\n`));
+        start(controller) {
+            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`));
+        },
+        pull(controller) {
+            if (contentQueue.length === 0) {
+                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'));
+                controller.close();
+                return;
             }
+            const char = contentQueue.shift();
+            const chunk = { id: streamId, object: 'chat.completion.chunk', created: creationTime, model: modelName, choices: [{ index: 0, delta: { content: char }, finish_reason: null }] };
+            controller.enqueue(encoder.encode(`data: ${JSON.stringify(chunk)}\n\n`));
         }
-        controller.enqueue(encoder.encode(`data: ${JSON.stringify({ id: streamId, object: 'chat.completion.chunk', created: creationTime, model: modelName, choices: [{ index: 0, delta: {}, finish_reason: 'stop' }] })}\n\n`));
-        controller.enqueue(encoder.encode('data: [DONE]\n\n'));
-        controller.close();
-      }
     });
   }
   
   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" } });
+    try {
+      const googleModels = await this.googleAI.fetchOfficialModels();
+      const models = {
+        object: "list",
+        data: googleModels.map(model => ({
+            id: model.name.replace('models/', ''), object: "model", created: Math.floor(Date.now() / 1000), owned_by: "google",
+        }))
+      };
+      // [新增] 在模型列表中加入TTS模型以提高兼容性
+      models.data.push({ id: "tts-1", object: "model", created: Math.floor(Date.now() / 1000), owned_by: "google" });
+      models.data.push({ id: "tts-1-hd", object: "model", created: Math.floor(Date.now() / 1000), owned_by: "google" });
+
+      return new Response(JSON.stringify(models), { headers: { "Content-Type": "application/json" } });
+    } catch (error) {
+      console.error("Error fetching models:", error);
+      return new Response(JSON.stringify({ error: { message: "Failed to fetch models." } }), { status: 500 });
+    }
   }
   
   private async handleStatus(): Promise<Response> {
-      return new Response(JSON.stringify({ status: "healthy", timestamp: new Date().toISOString(), version: "2.5.2" }), { headers: { "Content-Type": "application/json" } });
+      const status = {
+          status: "healthy", timestamp: new Date().toISOString(), version: "2.6.0-tts",
+          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 = { "Access-Control-Allow-Origin": "*", "Access-Control-Allow-Methods": "GET, POST, OPTIONS", "Access-Control-Allow-Headers": "Content-Type, Authorization" };
+    const corsHeaders = {
+      "Access-Control-Allow-Origin": "*",
+      "Access-Control-Allow-Methods": "GET, POST, OPTIONS",
+      "Access-Control-Allow-Headers": "Content-Type, Authorization",
+    };
+
     if (request.method === "OPTIONS") return new Response(null, { headers: corsHeaders });
 
     const url = new URL(request.url);
     let response: Response;
 
-    try {
-        if (url.pathname === "/health" || url.pathname === "/status") response = await this.handleStatus();
-        else if (!this.authenticate(request)) response = new Response(JSON.stringify({ error: "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 || "Internal server error." } }), { status: 500 });
+    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/chat/completions" && request.method === "POST") {
+      response = await this.handleChatCompletions(request);
+    } else if (url.pathname === "/v1/models" && request.method === "GET") {
+      response = await this.handleModels();
+    } else if (url.pathname === "/v1/audio/speech" && request.method === "POST") { // [新增] TTS 路由
+      response = await this.handleAudioSpeech(request);
+    } else {
+      response = new Response("Not Found", { status: 404 });
     }
 
     const finalHeaders = new Headers(response.headers);
-    for (const [key, value] of Object.entries(corsHeaders)) finalHeaders.set(key, value);
-    return new Response(response.body, { status: response.status, statusText: response.statusText, headers: finalHeaders });
+    Object.entries(corsHeaders).forEach(([key, value]) => finalHeaders.set(key, value));
+    return new Response(response.body, { status: response.status, headers: finalHeaders });
   }
 }
 
 // --- 服务器启动 ---
 const server = new OpenAICompatibleServer();
-const port = 7860;
-console.log(`🚀 Server starting on http://localhost:${port}`);
-server['googleAI'].fetchOfficialModels().catch(e => console.warn(`⚠️ Could not pre-fetch models: ${e.message}`));
-await serve((req: Request) => server.handleRequest(req), { port });
+
+console.log("🚀 OpenAI Compatible Server with Google AI starting on port 7860...");
+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 pre-fetched ${models.length} generative models.`))
+  .catch(error => console.warn(`⚠️ Could not pre-fetch models: ${error.message}.`));
+
+console.log("\n🔗 Endpoints:");
+console.log("   POST /v1/chat/completions");
+console.log("   POST /v1/audio/speech     <-- [NEW] TTS Endpoint");
+console.log("   GET  /v1/models");
+console.log("   GET  /status");
+
+await serve(
+  (request: Request) => server.handleRequest(request),
+  { port: 7860 }
+);