Update main.ts

main.ts

@@ -1,429 +1,212 @@
-import { serve } from "https://deno.land/std@0.220.1/http/server.ts";
+// main.ts - Deno 版本的 ish2api 服务 (v1.0.2 - With Sponsor Adblock)
 
-// --- 配置常量 ---
-const AUTH_KEY = Deno.env.get("AUTH_KEY") ?? "default_api_key_value"; //API密钥在Environment Variables中添加，否则默认是default_api_key_value
-const TARGET_URL = 'https://assistant.on.adaptive.ai/api/sendMessage';
-const PROXY_MODEL_NAME = "gpt-4o"; // 代理服务返回的模型名称
+import { serve } from "https://deno.land/[email protected]/http/server.ts";
+import { load } from "https://deno.land/[email protected]/dotenv/mod.ts";
 
+// 加载环境变量
+const env = await load();
 
-const TARGET_HEADERS = {
-    'content-type': 'application/json',
-    'x-channel-id': "0"
-};
-
-// --- 辅助函数：创建 SSE 数据块 ---
-function createSSEChunk(id: string, model: string, content: string | null, role: string | null, finish_reason: string | null): string {
-    const now = Math.floor(Date.now() / 1000);
-    const chunk: any = {
-        id: id,
-        object: "chat.completion.chunk",
-        created: now,
-        model: model,
-        choices: [
-            {
-                index: 0,
-                delta: {},
-                finish_reason: finish_reason,
-                logprobs: null,
-            }
-        ],
-        // system_fingerprint: null, // 可选
-    };
-    if (role) {
-        chunk.choices[0].delta.role = role;
-    }
-    if (content) {
-        chunk.choices[0].delta.content = content;
-    }
-    // 如果 delta 为空且有 finish_reason，确保 delta 是空对象
-    if (!role && !content && finish_reason) {
-        chunk.choices[0].delta = {};
-    }
-
-    return `data: ${JSON.stringify(chunk)}\n\n`;
+// --- 类型定义 ---
+interface ChatMessage {
+  role: string;
+  content: string;
 }
 
-/**
- * 向 Adaptive AI 发送创建新聊天的请求。
- * 成功时返回新聊天的 ID (字符串)。
- * 如果在过程中发生任何错误，则捕获错误并返500。
- *
- * @returns {Promise<string | 500>} 返回成功创建的聊天的 ID (string)，或在失败时返回 500。
- */
-async function createChatAndGetId(): Promise<string> {
-    const url = 'https://assistant.on.adaptive.ai/api/createChat';
-    // 定义请求头 (省略了 cookie 和 priority)
-    const headers = {
-        'content-type': 'application/json',
-    };
-    // 构建请求体，使用当前时间戳作为请求 ID
-    const payload = {
-        json: {
-            jsonrpc: "2.0",
-            id: Date.now(), // 使用动态 ID
-            method: "createChat",
-            params: []
-        }
-    };
-    console.log("正在发送创建聊天请求...");
-    try {
-        const response = await fetch(url, {
-            method: 'POST',
-            headers: headers,
-            body: JSON.stringify(payload) // 将 payload 对象转换为 JSON 字符串
-        });
-        // 检查 HTTP 响应状态码是否表示成功
-        if (!response.ok) {
-            let errorBody = "无法读取响应体";
-            try {
-                errorBody = await response.text(); // 尝试读取错误响应体
-            } catch (readError) {
-                console.warn("读取错误响应体失败:", readError);
-            }
-            throw new Error(`创建聊天请求失败，HTTP 状态码: ${response.status}. 响应: ${errorBody}`);
-        }
-        // 解析 JSON 响应体
-        let responseData: any;
-        try {
-            responseData = await response.json();
-        } catch (parseError) {
-            // 如果响应不是有效的 JSON，则抛出错误
-            console.error("解析创建聊天响应 JSON 时出错:", parseError);
-            throw new Error(`无法将响应解析为 JSON: ${parseError.message}`);
-        }
-        // 提取并验证 ID
-        // ID 预期在 responseData.json.result.id
-        // 使用可选链操作符 (?.) 来安全地访问嵌套属性，防止因中间属性不存在而报错
-        const chatId = responseData?.json?.result?.id;
-        // 检查提取到的 ID 是否是一个有效的、非空的字符串
-        if (typeof chatId === 'string' && chatId.length > 0) {
-            console.log(`成功创建聊天，获取到 ID: ${chatId}`);
-            return chatId; // 返回提取到的 ID
-        } else {
-            // 如果 ID 不存在或格式不正确，则抛出错误
-            console.error("从响应中未能提取有效的聊天 ID。响应数据:", JSON.stringify(responseData));
-            throw new Error("创建聊天的响应格式无效或缺少 'json.result.id' 字段。");
-        }
-    } catch (error) {
-        // 捕获 try 块中抛出的任何错误，或 fetch 本身的网络错误
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        console.error("执行 createChatAndGetId 时发生错误:", errorMessage); // 记录详细错误信息
-        // 创建并返回一个 Response 对象
-        // 状态码为 500 (Internal Server Error)
-        // 响应体为 JSON 格式，包含错误信息
-        return new Response(
-            JSON.stringify({ error: `创建聊天会话失败: ${errorMessage}` }), // 将错误信息包装在 JSON 对象中
-            {
-                status: 500, // 设置 HTTP 状态码为 500
-                headers: {
-                    "Content-Type": "application/json", // 设置响应内容类型为 JSON
-                    "Access-Control-Allow-Origin": "*" // 如果需要跨域，添加此头
-                }
-            }
-        );
-    }
-
+interface OpenAIChatRequest {
+  model: string;
+  messages: ChatMessage[];
+  max_tokens?: number;
+  temperature?: number;
+  stream?: boolean;
 }
 
-// --- 主处理函数 ---
-async function handler(req: Request): Promise<Response> {
-    const url = new URL(req.url);
+// --- 配置 ---
+const POLLINATIONS_HEADERS = {
+  'Accept': '*/*',
+  'Accept-Encoding': 'gzip, deflate, br, zstd',
+  'Accept-Language': 'zh-CN,zh;q=0.9,en;q=0.8',
+  'Content-Type': 'application/json',
+  'Origin': 'https://ish.junioralive.in',
+  'Referer': 'https://ish.junioralive.in/',
+  'Sec-Ch-Ua': '"Not/A)Brand";v="8", "Chromium";v="126", "Microsoft Edge";v="126"',
+  'Sec-Ch-Ua-Mobile': '?0',
+  'Sec-Ch-Ua-Platform': '"Windows"',
+  'Sec-Fetch-Dest': 'empty',
+  'Sec-Fetch-Mode': 'cors',
+  'Sec-Fetch-Site': 'cross-site',
+  'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36 Edg/126.0.0.0',
+};
 
-    // --- CORS 预检请求处理 ---
-    if (req.method === "OPTIONS") {
-        return new Response(null, {
-            status: 204,
-            headers: {
-                "Access-Control-Allow-Origin": "*",
-                "Access-Control-Allow-Methods": "POST, OPTIONS",
-                "Access-Control-Allow-Headers": "Content-Type, Authorization",
-                "Access-Control-Max-Age": "86400",
-            },
-        });
+const TARGET_URL = env.TARGET_URL || Deno.env.get("TARGET_URL") || "https://text.pollinations.ai/openai";
+
+// --- 核心：流式代理函数 ---
+async function* streamProxy(requestBody: OpenAIChatRequest): AsyncGenerator<Uint8Array> {
+  try {
+    const response = await fetch(TARGET_URL, {
+      method: "POST",
+      headers: POLLINATIONS_HEADERS,
+      body: JSON.stringify(requestBody),
+    });
+
+    if (!response.ok) {
+      const errorText = await response.text();
+      const errorDetails = {
+        error: {
+          message: `Upstream API error: ${response.status}`,
+          type: "upstream_error",
+          details: errorText
+        }
+      };
+      const errorMessage = `data: ${JSON.stringify(errorDetails)}\n\n`;
+      yield new TextEncoder().encode(errorMessage);
+      console.error(`Error from upstream API: ${response.status} - ${errorText}`);
+      return;
     }
 
-
-    // 模型列表接口
-    if (url.pathname === "/v1/models" && req.method === "GET") {
-        return new Response(
-            JSON.stringify({
-                object: "list",
-                data: [
-                    {
-                        id: "gpt-4o",
-                        object: "model",
-                        created: 0,
-                        owned_by: "unlimitedai",
-                        permission: [{
-                            id: "modelperm-gpt-4o",
-                            object: "model_permission",
-                            created: 0,
-                            allow_create_engine: false,
-                            allow_sampling: true,
-                            allow_logprobs: false,
-                            allow_search_indices: false,
-                            allow_view: true,
-                            allow_fine_tuning: false,
-                            organization: "*",
-                            group: null,
-                            is_blocking: false,
-                        }],
-                        root: "gpt-4o",
-                        parent: null,
-                    },
-                ],
-            }),
-            {
-                status: 200,
-                headers: {
-                    "Content-Type": "application/json",
-                    "Access-Control-Allow-Origin": "*",
-                },
-            }
-        );
+    if (!response.body) {
+      throw new Error("Response body is null");
     }
 
-    // --- 路径和方法检查 ---
-    if (url.pathname !== "/v1/chat/completions" || req.method !== "POST") {
-        return new Response(JSON.stringify({ error: "Not Found or Method Not Allowed" }), {
-            status: 404,
-            headers: {
-                "Content-Type": "application/json",
-                "Access-Control-Allow-Origin": "*",
-            },
-        });
-    }
-    // --- 添加认证检查 ---
-    const authHeader = req.headers.get("Authorization");
-    let providedKey = "";
-    // 检查 Authorization header 是否存在且格式正确 (Bearer <key>)
-    if (!authHeader || !authHeader.toLowerCase().startsWith("bearer ")) {
-        console.warn(`认证失败: 缺少或格式错误的 Authorization header`);
-        return new Response(JSON.stringify({
-            error: {
-                message: "Unauthorized: Missing or invalid Authorization header. Use 'Bearer <YOUR_API_KEY>' format.",
-                type: "invalid_request_error",
-                param: null,
-                code: "missing_or_invalid_header"
-            }
-        }), {
-            status: 401, // Unauthorized
-            headers: {
-                "Content-Type": "application/json",
-                "Access-Control-Allow-Origin": "*",
-                "WWW-Authenticate": 'Bearer realm="API Access"'
-            }
-        });
-    }
-    // 提取 key 部分
-    providedKey = authHeader.substring(7); // "Bearer ".length is 7
-    console.log("providedKey：" + providedKey);
-    // 直接比较提供的 key 和硬编码的 key
-    if (providedKey !== AUTH_KEY) {
-        console.warn(`认证失败: 无效的 API Key 提供`);
-        return new Response(JSON.stringify({
-            error: {
-                message: "Unauthorized: Invalid API Key provided.",
-                type: "invalid_request_error",
-                param: null,
-                code: "inAUTH_KEY"
-            }
-        }), {
-            status: 401, // Unauthorized
-            headers: {
-                "Content-Type": "application/json",
-                "Access-Control-Allow-Origin": "*",
-                "WWW-Authenticate": 'Bearer realm="API Access"'
-            }
-        });
-    }
+    const reader = response.body.getReader();
+    const textDecoder = new TextDecoder();
 
-    // --- 处理 POST 请求 ---
     try {
-
-        // 1. 解析入站请求体
-        let requestBody: any;
-        try {
-            requestBody = await req.json();
-            console.log(requestBody)
-        } catch (e) {
-            console.error("Failed to parse request JSON:", e);
-            return new Response(JSON.stringify({ error: "Invalid JSON in request body" }), {
-                status: 400, headers: { "Content-Type": "application/json", "Access-Control-Allow-Origin": "*" },
-            });
+      while (true) {
+        const { done, value } = await reader.read();
+        
+        if (done) break;
+
+        // =================== 广告过滤逻辑开始 ===================
+        // 将二进制块解码为字符串以便检查内容
+        const chunkStr = textDecoder.decode(value, { stream: true });
+
+        // 检查解码后的字符串是否包含 "Sponsor" 关键词
+        if (chunkStr.includes("Sponsor")) {
+          console.log("Sponsor content detected. Stopping the stream to the client.");
+          // 发现广告，立即中断循环，不再向客户端发送任何数据
+          break;
         }
+        
+        // 如果没有广告，将原始的二进制块转发给客户端
+        yield value;
+        // =================== 广告过滤逻辑结束 ===================
+      }
+    } finally {
+      reader.releaseLock();
+    }
 
-        // 2. 检查是否请求流式响应
-        const isStream = requestBody.stream === true;
-
-        // 3. 提取用户输入的内容 - 将 messages 数组转换为字符串
-        let userContent: string | undefined;
-        if (Array.isArray(requestBody.messages) && requestBody.messages.length > 0) {
-            try {
-                // 直接将整个 messages 数组转换为 JSON 字符串
-                userContent = JSON.stringify(requestBody.messages);
-            } catch (e) {
-                console.error("Failed to stringify 'messages' array:", e);
-                // 如果 JSON.stringify 失败 (虽然对数组不太可能，但以防万一)
-                return new Response(JSON.stringify({ error: "Failed to process 'messages' array." }), {
-                    status: 400, headers: { "Content-Type": "application/json", "Access-Control-Allow-Origin": "*" },
-                });
-            }
-        }
-        // 检查 userContent 是否成功生成
-        // 如果 requestBody.messages 不存在、不是数组、为空，或者转换出错，userContent 会是 undefined
-        if (!userContent) {
-            console.error("Request body must contain a non-empty 'messages' array.");
-            return new Response(JSON.stringify({ error: "Request body must contain a non-empty 'messages' array." }), {
-                status: 400, headers: { "Content-Type": "application/json", "Access-Control-Allow-Origin": "*" },
-            });
-        }
-
-        // 现在 userContent 包含了整个对话历史的字符串表示
-        console.log("Formatted user content:", userContent); // 可以取消注释来调试输出
-
-        const CHAT_ID = await createChatAndGetId();//获取新的聊天ID
-
-
-        // 4. 构建目标 API Payload
-        const payload = {
-            json: {
-                jsonrpc: "2.0", id: Date.now(), method: "sendMessage",
-                params: [{ chatId: CHAT_ID, content: userContent, fileId: null, fileIds: [] }]
-            },
-            meta: { values: { "params.0.fileId": ["undefined"] } }
-        };
+  } catch (error) {
+    const errorDetails = {
+      error: {
+        message: `An unexpected error occurred: ${error.message}`,
+        type: "proxy_error"
+      }
+    };
+    const errorMessage = `data: ${JSON.stringify(errorDetails)}\n\n`;
+    yield new TextEncoder().encode(errorMessage);
+    console.error(`An unexpected error occurred: ${error}`);
+  }
+}
 
-        // 5. 发送请求到目标 API (无论是否流式，都需要先获取完整响应)
-        console.log("Forwarding request to:", TARGET_URL);
-        const targetResponse = await fetch(TARGET_URL, {
-            method: 'POST', headers: TARGET_HEADERS, body: JSON.stringify(payload),
-        });
+// --- 路由处理 ---
+async function handleChatCompletions(request: Request): Promise<Response> {
+  try {
+    const payload = await request.json() as OpenAIChatRequest;
+    
+    // 强制启用流式传输
+    const requestBody = {
+      ...payload,
+      stream: true
+    };
 
-        // 6. 处理目标 API 的响应
-        if (!targetResponse.ok) {
-            const errorBody = await targetResponse.text();
-            console.error(`Target API Error (${targetResponse.status}):`, errorBody);
-            // 即使是流式请求失败，也返回 JSON 错误
-            return new Response(JSON.stringify({ error: `Upstream API request failed with status ${targetResponse.status}`, details: errorBody }), {
-                status: 502, headers: { "Content-Type": "application/json", "Access-Control-Allow-Origin": "*" },
-            });
-        }
+    console.log(`Forwarding request for model '${payload.model}' to ${TARGET_URL}`);
 
-        // 7. 解析目标 API 的 JSON 响应
-        let targetData: any;
+    const stream = new ReadableStream({
+      async start(controller) {
         try {
-            targetData = await targetResponse.json();
-        } catch (e) {
-            console.error("Failed to parse target API response JSON:", e);
-            // 即使是流式请求失败，也返回 JSON 错误
-            return new Response(JSON.stringify({ error: "Failed to parse upstream API response" }), {
-                status: 500, headers: { "Content-Type": "application/json", "Access-Control-Allow-Origin": "*" },
-            });
-        }
-
-        // 8. 从目标响应中提取内容
-        const assistantContent = targetData?.json?.result?.content;
-        if (typeof assistantContent !== 'string') {
-            console.error("Could not extract 'content' from target API response:", JSON.stringify(targetData));
-            // 即使是流式请求失败，也返回 JSON 错误
-            return new Response(JSON.stringify({ error: "Invalid response format from upstream API" }), {
-                status: 500, headers: { "Content-Type": "application/json", "Access-Control-Allow-Origin": "*" },
-            });
-        }
-
-        // 9. 根据 isStream 决定返回格式
-        const chatCompletionId = `chatcmpl-${crypto.randomUUID()}`; // 为本次交互生成唯一 ID
-        const modelName = requestBody.model || PROXY_MODEL_NAME; // 确定模型名称
-
-        if (isStream) {
-            // --- 返回模拟的流式响应 ---
-            console.log("Simulating stream response...");
-            const encoder = new TextEncoder();
-            const stream = new ReadableStream({
-                async start(controller) {
-                    try {
-                        // 模拟发送块
-                        // 块 1: 发送角色信息
-                        controller.enqueue(encoder.encode(
-                            createSSEChunk(chatCompletionId, modelName, null, "assistant", null)
-                        ));
-                        await new Promise(resolve => setTimeout(resolve, 10)); // 短暂延迟，模拟处理
-
-                        // 块 2: 发送完整内容
-                        controller.enqueue(encoder.encode(
-                            createSSEChunk(chatCompletionId, modelName, assistantContent, null, null)
-                        ));
-                        await new Promise(resolve => setTimeout(resolve, 10)); // 短暂延迟
-
-                        // 块 3: 发送结束信号
-                        controller.enqueue(encoder.encode(
-                            createSSEChunk(chatCompletionId, modelName, null, null, "stop")
-                        ));
-
-                        // 发送 [DONE] 标记
-                        controller.enqueue(encoder.encode("data: [DONE]\n\n"));
-
-                        // 关闭流
-                        controller.close();
-                    } catch (error) {
-                        console.error("Error during stream simulation:", error);
-                        controller.error(error); // 通知流出错了
-                    }
-                }
-            });
-
-            return new Response(stream, {
-                status: 200,
-                headers: {
-                    'Content-Type': 'text/event-stream',
-                    'Cache-Control': 'no-cache',
-                    'Connection': 'keep-alive', // 建议 SSE 使用
-                    'Access-Control-Allow-Origin': '*'
-                },
-            });
-
-        } else {
-            // --- 返回完整的 JSON 响应 ---
-            console.log("Returning non-stream response.");
-            const finalResponse = {
-                id: chatCompletionId,
-                object: "chat.completion",
-                created: Math.floor(Date.now() / 1000),
-                model: modelName,
-                choices: [
-                    {
-                        index: 0,
-                        message: {
-                            role: "assistant",
-                            content: assistantContent,
-                        },
-                        finish_reason: "stop",
-                        logprobs: null,
-                    }
-                ],
-                usage: { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 },
-            };
-
-            return new Response(JSON.stringify(finalResponse), {
-                status: 200,
-                headers: {
-                    'Content-Type': 'application/json',
-                    'Access-Control-Allow-Origin': '*'
-                },
-            });
+          for await (const chunk of streamProxy(requestBody)) {
+            controller.enqueue(chunk);
+          }
+          controller.close();
+        } catch (error) {
+          controller.error(error);
         }
+      }
+    });
+
+    return new Response(stream, {
+      headers: {
+        'Content-Type': 'text/event-stream',
+        'Cache-Control': 'no-cache',
+        'Connection': 'keep-alive',
+        'Access-Control-Allow-Origin': '*',
+        'Access-Control-Allow-Methods': 'POST, GET, OPTIONS',
+        'Access-Control-Allow-Headers': 'Content-Type, Authorization',
+      },
+    });
+
+  } catch (error) {
+    console.error('Error parsing request:', error);
+    return new Response(JSON.stringify({
+      error: {
+        message: 'Invalid request format',
+        type: 'request_error'
+      }
+    }), {
+      status: 400,
+      headers: { 'Content-Type': 'application/json' }
+    });
+  }
+}
 
-    } catch (error) {
-        // --- 全局错误处理 ---
-        console.error("Unhandled error in handler:", error);
-        // 即使请求流式，也返回 JSON 错误
-        return new Response(JSON.stringify({ error: "Internal Server Error" }), {
-            status: 500,
-            headers: { "Content-Type": "application/json", "Access-Control-Allow-Origin": "*" },
-        });
+// --- 主处理函数 ---
+async function handler(request: Request): Promise<Response> {
+  const url = new URL(request.url);
+  const { pathname, method } = { pathname: url.pathname, method: request.method };
+
+  // 处理 CORS 预检请求
+  if (method === 'OPTIONS') {
+    return new Response(null, {
+      headers: {
+        'Access-Control-Allow-Origin': '*',
+        'Access-Control-Allow-Methods': 'POST, GET, OPTIONS',
+        'Access-Control-Allow-Headers': 'Content-Type, Authorization',
+      },
+    });
+  }
+
+  // 路由分发
+  if (pathname === '/v1/chat/completions' && method === 'POST') {
+    return handleChatCompletions(request);
+  }
+
+  if (pathname === '/' && method === 'GET') {
+    return new Response(JSON.stringify({
+      message: "Pollinations OpenAI-Compatible Proxy is running. Use the /v1/chat/completions endpoint.",
+      version: "1.0.2",
+      target_url: TARGET_URL
+    }), {
+      headers: { 'Content-Type': 'application/json' }
+    });
+  }
+
+  // 404 处理
+  return new Response(JSON.stringify({
+    error: {
+      message: 'Not Found',
+      type: 'not_found'
     }
+  }), {
+    status: 404,
+    headers: { 'Content-Type': 'application/json' }
+  });
 }
 
+// --- 启动服务器 ---
+const port = parseInt(Deno.env.get("PORT") || "7860");
+
+console.log("Starting Deno server...");
+console.log(`Forwarding requests to: ${TARGET_URL}`);
+console.log(`OpenAI compatible endpoint available at: http://127.0.0.1:${port}/v1/chat/completions`);
 
-serve(handler, { port: 7860 });
+await serve(handler, { port });