Update main.ts

main.ts

@@ -1,799 +1,352 @@
-import { serve } from "https://deno.land/std@0.220.1/http/server.ts";
-
-// 定义常量
-const SOPHNET_BASE_URL = "https://www.sophnet.com/api";
-const PROJECT_UUID = "Ar79PWUQUAhjJOja2orHs";
-const PORT = 7860;
-const TOKEN_KEY = "sophnet_anonymous_token";
-const MAX_RETRIES = 5; // 增加最大重试次数
-const INITIAL_RETRY_DELAY_MS = 100; // 初始重试延迟（毫秒）
-const MAX_RETRY_DELAY_MS = 5000; // 最大重试延迟（毫秒）
-
-// 初始化Deno KV
-const kv = await Deno.openKv();
-
-// 定义接口
-interface AnonymousTokenResponse {
-  status: number;
-  message: string;
-  result: {
-    anonymousToken: string;
-    expires: string;
-  };
-  timestamp: number;
-}
-
-interface SophNetModel {
-  id: number;
-  serviceUuid: string | null;
-  projectUuid: string;
-  displayName: string;
-  modelFamily: string;
-  available: boolean;
-  isBaseModel: boolean;
-  features: any;
-  supportedStream: boolean;
-  supportedImageInputs: boolean;
-  schema: Array<{
-    name: string;
-    displayName: string;
-    des: string;
-    type: string;
-    range: number[];
-    defaultValue: number;
-    required: boolean;
-  }>;
-}
-
-interface ModelsResponse {
-  status: number;
-  message: string;
-  result: SophNetModel[];
-  timestamp: number;
-}
-
-interface TokenInfo {
-  token: string;
-  expires: string;
-}
-
-interface Message {
-  role: string;
-  content: string;
-}
-
-interface Reference {
-  content: string;
-  id: string;
-  index: number;
-  title: string;
-  type: string;
-  url: string;
-}
-
-// 随机生成一个用户代理字符串
-function getRandomUserAgent(): string {
-  const userAgents = [
-    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/108.0.0.0 Safari/537.36",
-    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.1 Safari/605.1.15",
-    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/119.0.0.0 Safari/537.36 Edg/119.0.2151.44",
-    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/119.0.0.0 Safari/537.36",
-    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/119.0.0.0 Safari/537.36",
-    "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/119.0.0.0 Safari/537.36",
-    "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:109.0) Gecko/20100101 Firefox/119.0",
-    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:109.0) Gecko/20100101 Firefox/119.0",
-    "Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:109.0) Gecko/20100101 Firefox/119.0",
-  ];
-  return userAgents[Math.floor(Math.random() * userAgents.length)];
-}
-
-// 计算指数退避延迟
-function getExponentialBackoffDelay(retryCount: number): number {
-  const delay = INITIAL_RETRY_DELAY_MS * Math.pow(2, retryCount);
-  const jitter = Math.random() * INITIAL_RETRY_DELAY_MS; // 添加随机抖动
-  return Math.min(delay + jitter, MAX_RETRY_DELAY_MS);
-}
-
-// 延迟函数
-function sleep(ms: number): Promise<void> {
-  return new Promise(resolve => setTimeout(resolve, ms));
-}
-
-// 从KV获取token
-async function getTokenFromKV(): Promise<TokenInfo | null> {
-  const tokenEntry = await kv.get<TokenInfo>([TOKEN_KEY]);
-  return tokenEntry.value;
-}
-
-// 存储token到KV
-async function storeTokenToKV(token: string, expires: string): Promise<void> {
-  await kv.set([TOKEN_KEY], { token, expires });
-}
-
-// 获取匿名token
-async function getAnonymousToken(retryCount = 0): Promise<string> {
-  try {
-    const response = await fetch(`${SOPHNET_BASE_URL}/sys/login/anonymous`, {
-      method: "GET",
-      headers: {
-        "Accept": "application/json",
-        "User-Agent": getRandomUserAgent(), // 使用随机UA
-      },
-    });
-
-    // 如果是 429 或 500 错误，进行重试
-    if ((response.status === 429 || response.status >= 500) && retryCount < MAX_RETRIES) {
-      const delay = getExponentialBackoffDelay(retryCount);
-      console.warn(`Get token failed with status ${response.status}. Retrying in ${delay}ms... (${retryCount + 1}/${MAX_RETRIES})`);
-      await sleep(delay);
-      return getAnonymousToken(retryCount + 1);
-    }
-
-    if (!response.ok) {
-      throw new Error(`Failed to get token: ${response.status}`);
-    }
-
-    const data = await response.json() as AnonymousTokenResponse;
-    await storeTokenToKV(data.result.anonymousToken, data.result.expires);
-    return data.result.anonymousToken;
-  } catch (error) {
-    console.error("Error getting anonymous token:", error);
-    throw error;
+import { serve } from "https://deno.land/std@0.208.0/http/server.ts";
+
+// Julep API Base URL (fixed)
+const JULEP_API_BASE = "https://api.julep.ai/api";
+
+// Hardcoded list of models (Agent IDs in this context)
+const HARDCODED_MODELS = [
+  'mistral-large-2411', 'o1', 'text-embedding-3-large', 'vertex_ai/text-embedding-004',
+  'claude-3.5-haiku', 'cerebras/llama-4-scout-17b-16e-instruct', 'llama-3.1-8b',
+  'magnum-v4-72b', 'voyage-multilingual-2', 'claude-3-haiku', 'gpt-4o',
+  'BAAI/bge-m3', 'openrouter/meta-llama/llama-4-maverick', 'openrouter/meta-llama/llama-4-scout',
+  'claude-3.5-sonnet', 'hermes-3-llama-3.1-70b', 'claude-3.5-sonnet-20240620',
+  'qwen-2.5-72b-instruct', 'l3.3-euryale-70b', 'gpt-4o-mini', 'cerebras/llama-3.3-70b',
+  'o1-preview', 'gemini-1.5-pro-latest', 'l3.1-euryale-70b', 'claude-3-sonnet',
+  'Alibaba-NLP/gte-large-en-v1.5', 'openrouter/meta-llama/llama-4-scout:free',
+  'llama-3.1-70b', 'eva-qwen-2.5-72b', 'claude-3.5-sonnet-20241022', 'gemini-2.0-flash',
+  'deepseek-chat', 'o1-mini', 'eva-llama-3.33-70b', 'gemini-2.5-pro-preview-03-25',
+  'gemini-1.5-pro', 'gpt-4-turbo', 'openrouter/meta-llama/llama-4-maverick:free',
+  'o3-mini', 'claude-3.7-sonnet', 'voyage-3', 'cerebras/llama-3.1-8b', 'claude-3-opus'
+];
+
+// Helper function to get Julep API Key from Authorization header
+function getJulepApiKey(req: Request): string | null {
+  const authHeader = req.headers.get("Authorization");
+  if (authHeader && authHeader.startsWith("Bearer ")) {
+    return authHeader.substring(7); // Extract the token after "Bearer "
   }
+  return null;
 }
 
-// 获取有效token
-async function getValidToken(): Promise<string> {
-  // 先尝试从KV获取
-  const tokenInfo = await getTokenFromKV();
-
-  // 如果KV中有token且未过期，则使用该token
-  if (tokenInfo && new Date(tokenInfo.expires) > new Date()) {
-    return tokenInfo.token;
+// OpenAI Models endpoint handler (hardcoded)
+async function handleModels(req: Request): Promise<Response> {
+  const julepApiKey = getJulepApiKey(req);
+  if (!julepApiKey) {
+    return new Response("Unauthorized: Missing or invalid Authorization header", { status: 401 });
   }
 
-  // 否则获取新token
-  return await getAnonymousToken();
-}
-
-// 获取模型列表
-async function getModels(token: string, retryCount = 0): Promise<SophNetModel[]> {
-  try {
-    const response = await fetch(
-      `${SOPHNET_BASE_URL}/public/playground/models?projectUuid=${PROJECT_UUID}`,
+  // Format hardcoded models into OpenAI models format
+  const openaiModels = HARDCODED_MODELS.map((modelId) => ({
+    id: modelId,
+    object: "model",
+    created: Math.floor(Date.now() / 1000), // Use current time for creation
+    owned_by: "julep", // Or "openai" if you prefer
+    permission: [
       {
-        method: "GET",
-        headers: {
-          "Accept": "application/json",
-          "User-Agent": getRandomUserAgent(), // 使用随机UA
-          "Authorization": `Bearer anon-${token}`,
-        },
-      },
-    );
-
-    // 如果是401或403错误，尝试刷新token并重试
-    if ((response.status === 401 || response.status === 403) && retryCount < MAX_RETRIES) {
-      console.log(`Token expired, refreshing and retrying models request (${retryCount + 1}/${MAX_RETRIES})...`);
-      const newToken = await getAnonymousToken();
-      return await getModels(newToken, retryCount + 1);
-    }
-    
-    // 如果是 429 或 500 错误，进行重试
-    if ((response.status === 429 || response.status >= 500) && retryCount < MAX_RETRIES) {
-        const delay = getExponentialBackoffDelay(retryCount);
-        console.warn(`Get models failed with status ${response.status}. Retrying in ${delay}ms... (${retryCount + 1}/${MAX_RETRIES})`);
-        await sleep(delay);
-        return getModels(token, retryCount + 1); // 使用当前token重试，如果失败会在上面的逻辑中刷新
-    }
-
-    if (!response.ok) {
-      throw new Error(`Failed to get models: ${response.status}`);
-    }
-
-    const data = await response.json() as ModelsResponse;
-
-    // 请求成功后获取新token并存储 (后台刷新)
-    getAnonymousToken().catch(err => console.error("Background token refresh failed:", err));
-
-    return data.result;
-  } catch (error) {
-    console.error("Error getting models:", error);
-    throw error;
-  }
-}
-
-// 将SophNet模型转换为OpenAI格式
-function transformModelsToOpenAIFormat(models: SophNetModel[]) {
-  const transformedModels = [];
-
-  // 为每个模型创建标准版本、搜索版本和全上下文版本
-  for (const model of models) {
-    // 添加标准模型
-    transformedModels.push({
-      id: model.modelFamily,
-      object: "model",
-      created: Date.now(),
-      owned_by: "sophnet",
-      permission: [{
-        id: `modelperm-${model.id}`,
+        id: `modelperm-${modelId}`,
         object: "model_permission",
-        created: Date.now(),
+        created: Math.floor(Date.now() / 1000),
         allow_create_engine: false,
         allow_sampling: true,
-        allow_logprobs: false,
+        allow_logprobs: true,
         allow_search_indices: false,
         allow_view: true,
         allow_fine_tuning: false,
         organization: "*",
         group: null,
         is_blocking: false,
-      }],
-      root: model.modelFamily,
-      parent: null,
-    });
-
-    // 添加搜索版本模型
-    transformedModels.push({
-      id: `${model.modelFamily}-Search`,
-      object: "model",
-      created: Date.now(),
-      owned_by: "sophnet",
-      permission: [{
-        id: `modelperm-${model.id}-Search`,
-        object: "model_permission",
-        created: Date.now(),
-        allow_create_engine: false,
-        allow_sampling: true,
-        allow_logprobs: false,
-        allow_search_indices: true,
-        allow_view: true,
-        allow_fine_tuning: false,
-        organization: "*",
-        group: null,
-        is_blocking: false,
-      }],
-      root: model.modelFamily,
-      parent: null,
-    });
-
-    // 添加全上下文版本模型
-    transformedModels.push({
-      id: `${model.modelFamily}-Full-Context`,
-      object: "model",
-      created: Date.now(),
-      owned_by: "sophnet",
-      permission: [{
-        id: `modelperm-${model.id}-Full-Context`,
-        object: "model_permission",
-        created: Date.now(),
-        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: model.modelFamily,
-      parent: null,
-    });
-
-    // 添加全上下文+搜索版本模型
-    transformedModels.push({
-      id: `${model.modelFamily}-Full-Context-Search`,
-      object: "model",
-      created: Date.now(),
-      owned_by: "sophnet",
-      permission: [{
-        id: `modelperm-${model.id}-Full-Context-Search`,
-        object: "model_permission",
-        created: Date.now(),
-        allow_create_engine: false,
-        allow_sampling: true,
-        allow_logprobs: false,
-        allow_search_indices: true,
-        allow_view: true,
-        allow_fine_tuning: false,
-        organization: "*",
-        group: null,
-        is_blocking: false,
-      }],
-      root: model.modelFamily,
-      parent: null,
-    });
-  }
+      },
+    ],
+    root: modelId,
+    parent: null,
+  }));
 
-  return {
-    object: "list",
-    data: transformedModels,
-  };
+  return new Response(JSON.stringify({ data: openaiModels, object: "list" }), {
+    headers: { "Content-Type": "application/json" },
+    status: 200,
+  });
 }
 
-// 处理全上下文功能
-function processFullContext(messages: Message[]): Message[] {
-  // 复制消息数组，避免修改原数组
-  const messagesCopy = [...messages];
-
-  // 提取系统消息（如果存在）
-  const systemMessages = messagesCopy.filter(msg => msg.role === "system");
-
-  // 获取非系统消息
-  const nonSystemMessages = messagesCopy.filter(msg => msg.role !== "system");
-
-  // 如果消息总数少于或等于3对（6条消息），则不需要处理
-  if (nonSystemMessages.length <= 6) {
-    return messages;
+// OpenAI Chat Completions endpoint handler
+async function handleChatCompletions(req: Request): Promise<Response> {
+  const julepApiKey = getJulepApiKey(req);
+  if (!julepApiKey) {
+    return new Response("Unauthorized: Missing or invalid Authorization header", { status: 401 });
   }
 
-  // 提取最后3轮对话（最多6条消息）
-  const recentMessages = nonSystemMessages.slice(-6);
-
-  // 提取需要合并的历史消息
-  const historyMessages = nonSystemMessages.slice(0, -6);
-
-  // 创建历史消息的摘要
-  const historySummary = {
-    role: "user",
-    content: `这里是此前的对话上下文: ${JSON.stringify(historyMessages)}`
+  const headers = {
+    "Authorization": `Bearer ${julepApiKey}`,
+    "Content-Type": "application/json",
   };
 
-  // 组合新的消息数组：系统消息 + 历史摘要 + 最近消息
-  return [...systemMessages, historySummary, ...recentMessages];
-}
-
-// 将数字转换为上标形式
-function convertToSuperscript(num: number): string {
-  const normalDigits = '0123456789';
-  const superscriptDigits = '⁰¹²³⁴⁵⁶⁷⁸⁹';
-
-  return num.toString()
-    .split('')
-    .map(char => {
-      const index = normalDigits.indexOf(char);
-      return index !== -1 ? superscriptDigits[index] : char;
-    })
-    .join('');
-}
-
-// 处理聊天完成请求
-async function handleChatCompletions(
-  token: string,
-  requestBody: any,
-  stream: boolean,
-  retryCount = 0,
-): Promise<Response> {
-  // 检查模型名称的后缀
-  const modelId = requestBody.model;
-  const webSearchEnable = modelId.includes("-Search");
-  const fullContextEnable = modelId.includes("-Full-Context");
-
-  // 根据后缀确定实际模型ID
-  let actualModelId = modelId;
-  if (webSearchEnable) actualModelId = actualModelId.replace("-Search", "");
-  if (fullContextEnable) actualModelId = actualModelId.replace("-Full-Context", "");
-
-  // 处理消息
-  let processedMessages = requestBody.messages;
-  if (fullContextEnable) {
-    processedMessages = processFullContext(requestBody.messages);
-  }
-
-  const sophNetBody = {
-    temperature: requestBody.temperature || 0.7,
-    top_p: requestBody.top_p || 0.9,
-    frequency_penalty: requestBody.frequency_penalty || 0,
-    presence_penalty: requestBody.presence_penalty || 0,
-    max_tokens: requestBody.max_tokens || 2048,
-    webSearchEnable: webSearchEnable,
-    stop: requestBody.stop || [],
-    stream: stream.toString(),
-    model_id: actualModelId,
-    messages: processedMessages,
-  };
+  let agentId: string | null = null; // Variable to store the created agent ID
+  let sessionId: string | null = null; // Variable to store the created session ID
 
   try {
-    const response = await fetch(
-      `${SOPHNET_BASE_URL}/open-apis/projects/${PROJECT_UUID}/chat/completions`,
-      {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          "Authorization": `Bearer anon-${token}`,
-          "Accept": stream ? "text/event-stream" : "application/json",
-          "User-Agent": getRandomUserAgent(), // 使用随机UA
-        },
-        body: JSON.stringify(sophNetBody),
-      },
-    );
-
-    // 如果是401或403错误，尝试刷新token并重试
-    if ((response.status === 401 || response.status === 403) && retryCount < MAX_RETRIES) {
-      console.log(`Chat completion token expired, refreshing and retrying (${retryCount + 1}/${MAX_RETRIES})...`);
-      const newToken = await getAnonymousToken();
-      // 使用指数退避等待
-      const delay = getExponentialBackoffDelay(retryCount);
-      await sleep(delay);
-      return await handleChatCompletions(newToken, requestBody, stream, retryCount + 1);
+    const requestBody = await req.json();
+    const { model, messages, stream, ...rest } = requestBody;
+
+    if (!model || !messages || !Array.isArray(messages) || messages.length === 0) {
+      return new Response("Invalid request body. 'model' and 'messages' are required.", { status: 400 });
     }
 
-    // 如果是 429 或 500 错误，进行指数退避重试
-    if ((response.status === 429 || response.status >= 500) && retryCount < MAX_RETRIES) {
-        const delay = getExponentialBackoffDelay(retryCount);
-        console.warn(`Chat completion failed with status ${response.status}. Retrying in ${delay}ms... (${retryCount + 1}/${MAX_RETRIES})`);
-        await sleep(delay);
-        return handleChatCompletions(token, requestBody, stream, retryCount + 1); // 使用当前token重试，如果失败会在上面的逻辑中刷新
+    // Check if the requested model is in our hardcoded list
+    if (!HARDCODED_MODELS.includes(model)) {
+       return new Response(`Invalid model: ${model}. Please use one of the available models.`, { status: 400 });
     }
 
-    if (!response.ok) {
-      throw new Error(`Chat completion failed: ${response.status}`);
+    // 1. Create a new Agent for this request
+    const createAgentUrl = `${JULEP_API_BASE}/agents`;
+    const createAgentBody = {
+      name: model, // Set agent name to the model value
+      model: model, // Use the requested OpenAI model as the Julep Agent's model
+      about: model, // Set agent about to the model value
+      instructions: ["Follow user instructions carefully."], // Keep some default instructions
+    };
+
+    const createAgentResponse = await fetch(createAgentUrl, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(createAgentBody),
+    });
+
+    if (!createAgentResponse.ok) {
+      const errorText = await createAgentResponse.text();
+      console.error(`Error creating Julep Agent: ${createAgentResponse.status} - ${errorText}`);
+      return new Response(`Error creating Julep Agent: ${createAgentResponse.statusText}`, { status: createAgentResponse.status });
     }
 
-    // 请求成功后获取新token并存储 (后台刷新)
-    getAnonymousToken().catch(err => console.error("Background token refresh failed:", err));
+    const agentData = await createAgentResponse.json();
+    agentId = agentData.id; // Store the agent ID
 
-    return response;
+    // 2. Create a Session using the new Agent ID
+    const createSessionUrl = `${JULEP_API_BASE}/sessions`;
+    const createSessionBody = {
+      agent: agentId, // Use the newly created Agent ID
+      // You can add other Session creation parameters here if needed
+    };
 
-  } catch (error) {
-    console.error("Error during chat completion fetch:", error);
-    // 如果是网络错误或其他非HTTP错误，也进行指数退避重试
-     if (retryCount < MAX_RETRIES) {
-        const delay = getExponentialBackoffDelay(retryCount);
-        console.warn(`Chat completion network error. Retrying in ${delay}ms... (${retryCount + 1}/${MAX_RETRIES})`);
-        await sleep(delay);
-        return handleChatCompletions(token, requestBody, stream, retryCount + 1);
-     }
-    throw error; // 达到最大重试次数后抛出错误
-  }
-}
+    const createSessionResponse = await fetch(createSessionUrl, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(createSessionBody),
+    });
 
-// 转换流式响应
-async function* transformStreamResponse(
-  readableStream: ReadableStream<Uint8Array>,
-) {
-  const reader = readableStream.getReader();
-  const decoder = new TextDecoder();
-  let buffer = "";
+    if (!createSessionResponse.ok) {
+      const errorText = await createSessionResponse.text();
+      console.error(`Error creating Julep Session: ${createSessionResponse.status} - ${errorText}`);
+      // Attempt to clean up the temporary agent
+      if (agentId) {
+         fetch(`${JULEP_API_BASE}/agents/${agentId}`, { method: "DELETE", headers }).catch(console.error);
+      }
+      return new Response(`Error creating Julep Session: ${createSessionResponse.statusText}`, { status: createSessionResponse.status });
+    }
 
-  // 用于存储所有引用，以便在结束时生成参考资料部分
-  const references: Reference[] = [];
-  let referencesEmitted = false; // 标记是否已经发送过参考资料部分
+    const sessionData = await createSessionResponse.json();
+    sessionId = sessionData.id; // Store the session ID
+
+    // 3. Perform Chat Completion
+    const chatUrl = `${JULEP_API_BASE}/sessions/${sessionId}/chat`;
+    const chatBody = {
+      messages: messages.map((msg: any) => ({
+        role: msg.role,
+        content: typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content), // Handle potential object content
+        // Map other relevant fields if necessary
+      })),
+      stream: stream === true,
+      ...rest, // Forward any other parameters from the OpenAI request
+    };
+
+    const chatResponse = await fetch(chatUrl, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(chatBody),
+    });
 
-  try {
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done) {
-        // 如果有引用但尚未发送，在结束前发送参考资料部分
-        if (references.length > 0 && !referencesEmitted) {
-          const referencesSection = generateReferencesSection(references);
-          yield `data: ${JSON.stringify({
-            id: `chatcmpl-${Date.now()}`, // 生成一个唯一的ID
-            object: "chat.completion.chunk",
-            created: Math.floor(Date.now() / 1000),
-            model: "sophnet-model", // 可以使用 SophNet 返回的模型名，或者固定一个
-            choices: [
-              {
-                index: 0,
-                delta: {
-                  content: `\n\n${referencesSection}`,
-                },
-                finish_reason: null, // 在发送参考资料时，finish_reason通常为null
-              },
-            ],
-          })}\n\n`;
-          referencesEmitted = true;
-        }
-        break;
+    // 4. Handle Response and Clean Up
+    if (!chatResponse.ok) {
+      // If the chat request itself fails, read the error body and then clean up
+      const errorText = await chatResponse.text();
+      console.error(`Error during Julep Chat Completion: ${chatResponse.status} - ${errorText}`);
+      // Attempt to clean up the temporary agent and session
+      if (sessionId) {
+         fetch(`${JULEP_API_BASE}/sessions/${sessionId}`, { method: "DELETE", headers }).catch(console.error);
+      }
+      if (agentId) {
+         fetch(`${JULEP_API_BASE}/agents/${agentId}`, { method: "DELETE", headers }).catch(console.error);
       }
+      return new Response(`Error during Julep Chat Completion: ${chatResponse.statusText} - ${errorText}`, { status: chatResponse.status });
+    }
 
-      buffer += decoder.decode(value, { stream: true });
-      const lines = buffer.split("\n");
-      buffer = lines.pop() || "";
-
-      for (const line of lines) {
-        if (line.trim() === "" || !line.startsWith("data:")) continue;
-
-        const data = line.substring(5).trim();
-        if (data === "[DONE]") {
-           // 如果有引用但尚未发送，在结束前发送参考资料部分
-          if (references.length > 0 && !referencesEmitted) {
-            const referencesSection = generateReferencesSection(references);
-            yield `data: ${JSON.stringify({
-              id: `chatcmpl-${Date.now()}`, // 生成一个唯一的ID
-              object: "chat.completion.chunk",
-              created: Math.floor(Date.now() / 1000),
-              model: "sophnet-model", // 可以使用 SophNet 返回的模型名，或者固定一个
-              choices: [
-                {
-                  index: 0,
+    if (stream) {
+      // Handle streaming response (Server-Sent Events)
+      // Pipe the Julep response body directly to the client response body
+      // and add cleanup to the end of the stream.
+      const readableStream = chatResponse.body!.pipeThrough(new TextDecoderStream()).pipeThrough(new TransformStream({
+        transform(chunk, controller) {
+          // Parse Julep streaming chunks and format as OpenAI SSE
+          const lines = chunk.split('\n').filter(line => line.trim() !== '');
+          for (const line of lines) {
+            if (line.startsWith('data:')) {
+              const data = JSON.parse(line.substring(5).trim());
+              // Format the Julep chunk data into OpenAI SSE format
+              const openaiChunk = {
+                id: data.id,
+                object: "chat.completion.chunk",
+                created: Math.floor(new Date(data.created_at).getTime() / 1000),
+                model: model, // Use the requested model ID
+                choices: data.choices.map((choice: any) => ({
+                  index: choice.index,
                   delta: {
-                    content: `\n\n${referencesSection}`,
+                    role: choice.delta.role,
+                    content: choice.delta.content,
+                    tool_calls: choice.delta.tool_calls ? toolCallDeltaToOpenAI(choice.delta.tool_calls) : undefined,
                   },
-                  finish_reason: null, // 在发送参考资料时，finish_reason通常为null
-                },
-              ],
-            })}\n\n`;
-            referencesEmitted = true;
+                  finish_reason: choice.finish_reason,
+                })),
+              };
+              controller.enqueue(`data: ${JSON.stringify(openaiChunk)}\n\n`);
+            } else {
+               // Pass through non-data lines like comments or empty lines if needed
+               controller.enqueue(`${line}\n`);
+            }
           }
-
-          yield "data: [DONE]\n\n";
-          continue;
-        }
-
-        try {
-          const sophNetEvent = JSON.parse(data);
-
-          // 检查是否包含引用
-          if (sophNetEvent.choices?.[0]?.refs && sophNetEvent.choices[0].refs.length > 0) {
-            // 处理引用
-            for (const ref of sophNetEvent.choices[0].refs) {
-              // 检查是否已经存在相同URL的引用
-              const existingRefIndex = references.findIndex(r => r.url === ref.url);
-              if (existingRefIndex === -1) {
-                // 添加新引用
-                references.push(ref);
-
-                // 生成引用标记，使用上标数字
-                const refIndex = references.length;
-                const superscriptIndex = `⁽${convertToSuperscript(refIndex)}⁾`;
-
-                // 创建带引用标记的事件
-                yield `data: ${JSON.stringify({
-                  id: sophNetEvent.id || `chatcmpl-${Date.now()}`, // 使用SophNet ID或生成新ID
-                  object: "chat.completion.chunk",
-                  created: Math.floor(Date.now() / 1000),
-                  model: sophNetEvent.model || "sophnet-model", // 使用SophNet模型名或固定
-                  choices: [
-                    {
-                      index: 0,
-                      delta: {
-                        // SophNet的引用信息通常不在content中，我们需要手动添加
-                        content: `[${superscriptIndex}](${ref.url})`,
-                      },
-                      finish_reason: null, // 引用事件通常没有finish_reason
-                    },
-                  ],
-                })}\n\n`;
+        },
+      }));
+
+      // Attach cleanup to the end of the stream
+      // We need to duplicate the stream to be able to pipe it to the client response
+      // AND to a WritableStream for cleanup.
+      const [stream1, stream2] = readableStream.tee();
+
+      const cleanupPromise = new Promise<void>((resolve, reject) => {
+          stream2.pipeTo(new WritableStream({
+              close: () => {
+                  if (sessionId) {
+                     fetch(`${JULEP_API_BASE}/sessions/${sessionId}`, { method: "DELETE", headers }).catch(console.error);
+                  }
+                  if (agentId) {
+                     fetch(`${JULEP_API_BASE}/agents/${agentId}`, { method: "DELETE", headers }).catch(console.error);
+                  }
+                  resolve();
+              },
+              abort: (reason) => {
+                  console.error("Stream aborted:", reason);
+                   if (sessionId) {
+                     fetch(`${JULEP_API_BASE}/sessions/${sessionId}`, { method: "DELETE", headers }).catch(console.error);
+                  }
+                  if (agentId) {
+                     fetch(`${JULEP_API_BASE}/agents/${agentId}`, { method: "DELETE", headers }).catch(console.error);
+                  }
+                  reject(reason);
               }
-            }
-          } else {
-            // 转换为OpenAI格式的事件
-            const openAIEvent = {
-              id: sophNetEvent.id || `chatcmpl-${Date.now()}`, // 使用SophNet ID或生成新ID
-              object: "chat.completion.chunk",
-              created: Math.floor(Date.now() / 1000),
-              model: sophNetEvent.model || "sophnet-model", // 使用SophNet模型名或固定
-              choices: [
-                {
-                  index: 0,
-                  delta: {
-                    // OpenAI通常将内容放在delta.content
-                    reasoning_content: sophNetEvent.choices?.[0]?.delta?.reasoning_content || "",
-                    content: sophNetEvent.choices?.[0]?.delta?.content || "",
-                  },
-                  finish_reason: sophNetEvent.choices?.[0]?.finish_reason || null,
-                },
-              ],
-            };
+          })).catch(reject);
+      });
 
-            yield `data: ${JSON.stringify(openAIEvent)}\n\n`;
-          }
-        } catch (e) {
-          console.error("Error parsing event:", e, "Line:", line);
-          // 可以选择在这里发送一个错误事件给客户端
-        }
+      // Return the response with the first stream.
+       return new Response(stream1, {
+        headers: {
+          "Content-Type": "text/event-stream",
+          "Cache-Control": "no-cache",
+          "Connection": "keep-alive",
+        },
+        status: 200,
+      });
+
+    } else {
+      // Handle non-streaming response
+      const julepChatData = await chatResponse.json();
+
+      const openaiCompletion = {
+        id: julepChatData.id,
+        object: "chat.completion",
+        created: Math.floor(new Date(julepChatData.created_at).getTime() / 1000),
+        model: model, // Use the requested model ID
+        choices: julepChatData.choices.map((choice: any) => ({
+          index: choice.index,
+          message: {
+            role: choice.message.role,
+            content: choice.message.content,
+            tool_calls: choice.message.tool_calls ? toolCallMessageToOpenAI(choice.message.tool_calls) : undefined,
+          },
+          finish_reason: choice.finish_reason,
+        })),
+        usage: julepChatData.usage ? {
+          prompt_tokens: julepChatData.usage.prompt_tokens,
+          completion_tokens: julepChatData.usage.completion_tokens,
+          total_tokens: julepChatData.usage.total_tokens,
+        } : undefined,
+      };
+
+      // Attempt to clean up the temporary agent and session (fire and forget)
+      if (sessionId) {
+         fetch(`${JULEP_API_BASE}/sessions/${sessionId}`, { method: "DELETE", headers }).catch(console.error);
+      }
+      if (agentId) {
+         fetch(`${JULEP_API_BASE}/agents/${agentId}`, { method: "DELETE", headers }).catch(console.error);
       }
+
+      return new Response(JSON.stringify(openaiCompletion), {
+        headers: { "Content-Type": "application/json" },
+        status: 200,
+      });
     }
-  } finally {
-    reader.releaseLock();
+
+  } catch (error) {
+    console.error("Error handling chat completions request:", error);
+    // Attempt to clean up in case of errors before session/agent creation
+     if (sessionId) {
+         fetch(`${JULEP_API_BASE}/sessions/${sessionId}`, { method: "DELETE", headers }).catch(console.error);
+      }
+      if (agentId) {
+         fetch(`${Julep_API_BASE}/agents/${agentId}`, { method: "DELETE", headers }).catch(console.error);
+      }
+    return new Response("Internal Server Error", { status: 500 });
   }
 }
 
-// 生成参考资料部分
-function generateReferencesSection(references: Reference[]): string {
-  if (references.length === 0) return "";
-
-  let section = "## 参考资料\n\n";
-  references.forEach((ref, index) => {
-    section += `${index + 1}. [${ref.title}](${ref.url})\n`;
+// Helper to format Julep ToolCall delta to OpenAI format
+function toolCallDeltaToOpenAI(julepToolCalls: any[]): any[] {
+  return julepToolCalls.map(toolCall => {
+    // Assuming Julep's delta format for tool_calls is similar to the message format
+    // and contains function objects directly. Adjust if necessary.
+    return {
+      id: toolCall.id,
+      type: "function",
+      function: {
+        name: toolCall.function?.name,
+        arguments: toolCall.function?.arguments, // Arguments might be streamed as chunks
+      },
+    };
   });
-
-  return section;
 }
 
-// 转换非流式响应
-async function transformNonStreamResponse(response: Response) {
-  const sophNetResponse = await response.json();
-
-  // 处理引用
-  let content = sophNetResponse.choices?.[0]?.message?.content || "";
-  const references: Reference[] = [];
-
-  // 收集所有引用
-  if (sophNetResponse.choices?.[0]?.message?.refs && sophNetResponse.choices[0].message.refs.length > 0) {
-    for (const ref of sophNetResponse.choices[0].message.refs) {
-      references.push(ref);
-    }
-
-    // 为每个引用添加上标标记
-    references.forEach((ref, index) => {
-      const refIndex = index + 1;
-      const superscriptIndex = `⁽${convertToSuperscript(refIndex)}⁾`;
-      // 在内容末尾添加引用标记
-      content += ` [${superscriptIndex}](${ref.url})`;
-    });
-
-    // 添加参考资料部分
-    if (references.length > 0) {
-      content += "\n\n" + generateReferencesSection(references);
-    }
-  }
-
-  return {
-    id: sophNetResponse.id || `chatcmpl-${Date.now()}`, // 使用SophNet ID或生成新ID
-    object: "chat.completion",
-    created: Math.floor(Date.now() / 1000),
-    model: sophNetResponse.model || "sophnet-model", // 使用SophNet模型名或固定
-    choices: [
-      {
-        index: 0,
-        message: {
-          role: "assistant",
-          reasoning_content: sophNetResponse.choices?.[0]?.message?.reasoning_content || "",
-          content: content,
-        },
-        finish_reason: sophNetResponse.choices?.[0]?.finish_reason || "stop",
+// Helper to format Julep ToolCall message to OpenAI format
+function toolCallMessageToOpenAI(julepToolCalls: any[]): any[] {
+  return julepToolCalls.map(toolCall => {
+    return {
+      id: toolCall.id,
+      type: "function",
+      function: {
+        name: toolCall.function?.name,
+        arguments: toolCall.function?.arguments, // Arguments should be complete in non-streaming
       },
-    ],
-    usage: sophNetResponse.usage || {
-      prompt_tokens: 0,
-      completion_tokens: 0,
-      total_tokens: 0,
-    },
-  };
+    };
+  });
 }
 
-// 主处理函数
+// Main request handler
 async function handler(req: Request): Promise<Response> {
   const url = new URL(req.url);
-  const path = url.pathname;
-
-  // CORS预检请求处理
-  if (req.method === "OPTIONS") {
-    return new Response(null, {
-      status: 204,
-      headers: {
-        "Access-Control-Allow-Origin": "*",
-        "Access-Control-Allow-Methods": "GET, POST, OPTIONS",
-        "Access-Control-Allow-Headers": "Content-Type, Authorization",
-        "Access-Control-Max-Age": "86400",
-      },
-    });
-  }
-
-  // 获取有效token
-  let token;
-  try {
-    token = await getValidToken();
-  } catch (error) {
-    console.error("Failed to get token in handler:", error);
-    return new Response(
-      JSON.stringify({ error: "Failed to get token", details: error.message }),
-      {
-        status: 500,
-        headers: {
-          "Content-Type": "application/json",
-          "Access-Control-Allow-Origin": "*",
-        },
-      },
-    );
-  }
-
-  try {
-    // 模型列表接口
-    if (path === "/v1/models" && req.method === "GET") {
-      const models = await getModels(token);
-      const openAIModels = transformModelsToOpenAIFormat(models);
 
-      return new Response(JSON.stringify(openAIModels), {
-        status: 200,
-        headers: {
-          "Content-Type": "application/json",
-          "Access-Control-Allow-Origin": "*",
-        },
-      });
-    }
-
-    // 聊天完成接口
-    else if (path === "/v1/chat/completions" && req.method === "POST") {
-      const requestBody = await req.json();
-      const stream = requestBody.stream === true;
-
-      const sophNetResponse = await handleChatCompletions(token, requestBody, stream);
-
-      if (stream) {
-        const transformedStream = new ReadableStream({
-          async start(controller) {
-            try {
-              for await (const chunk of transformStreamResponse(sophNetResponse.body!)) {
-                controller.enqueue(new TextEncoder().encode(chunk));
-              }
-              controller.close();
-            } catch (error) {
-              console.error("Stream transformation error:", error);
-              // 在流中发送错误信息
-              const errorData = JSON.stringify({
-                error: {
-                  message: `Stream processing error: ${error.message}`,
-                  type: "stream_error",
-                  code: null,
-                }
-              });
-              controller.enqueue(new TextEncoder().encode(`data: ${errorData}\n\n`));
-              controller.enqueue(new TextEncoder().encode("data: [DONE]\n\n"));
-              controller.close();
-            }
-          },
-        });
-
-        return new Response(transformedStream, {
-          headers: {
-            "Content-Type": "text/event-stream",
-            "Cache-Control": "no-cache",
-            "Connection": "keep-alive",
-            "Access-Control-Allow-Origin": "*",
-          },
-        });
-      } else {
-        const transformedResponse = await transformNonStreamResponse(sophNetResponse);
-
-        return new Response(JSON.stringify(transformedResponse), {
-          status: 200,
-          headers: {
-            "Content-Type": "application/json",
-            "Access-Control-Allow-Origin": "*",
-          },
-        });
-      }
-    }
-
-    // 未找到路由
-    else {
-      return new Response(
-        JSON.stringify({ error: "Not found", message: "Endpoint not supported" }),
-        {
-          status: 404,
-          headers: {
-            "Content-Type": "application/json",
-            "Access-Control-Allow-Origin": "*",
-          },
-        },
-      );
-    }
-  } catch (error) {
-    console.error("Request handling error:", error);
-
-    // 返回统一的错误响应格式
-    return new Response(
-      JSON.stringify({
-        error: {
-          message: error.message,
-          type: "api_error", // 或者更具体的错误类型
-          code: error.status || null, // 如果是HTTP错误，包含状态码
-        }
-      }),
-      {
-        status: error.status || 500, // 使用错误状态码或默认500
-        headers: {
-          "Content-Type": "application/json",
-          "Access-Control-Allow-Origin": "*",
-        },
-      },
-    );
+  if (url.pathname === "/v1/models" && req.method === "GET") {
+    return handleModels(req);
+  } else if (url.pathname === "/v1/chat/completions" && req.method === "POST") {
+    return handleChatCompletions(req);
+  } else {
+    return new Response("Not Found", { status: 404 });
   }
 }
 
-// 启动服务器
-console.log(`Starting server on port ${PORT}...`);
-serve(handler, { port: PORT });
+console.log(`HTTP server running on http://localhost:8000`);
+serve(handler, { port: 7860 });