Create main.ts

main.ts

@@ -0,0 +1,575 @@
+// file: openai_tau_proxy_confirm_newlines.ts
+
+/**
+ * Deno script to proxy OpenAI chat completion requests to a Tau API.
+ * Handles request/response format translation, including streaming and
+ * mapping Tau's 'g:' chunks to OpenAI's 'reasoning_content'.
+ * Also supports the /v1/models endpoint.
+ * Includes fix for model placement, configurable API key, explicit semicolons,
+ * quote cleaning, and debug logging to confirm newline escaping in JSON.
+ */
+
+// --- Constants ---
+const TAU_API_URL = "https://tau-api.fly.dev/v1/chat";
+const DEFAULT_TAU_MODEL = "anthropic-claude-4-opus"; // Default if client model isn't found or mapped
+const ALLOWED_TAU_MODELS = [
+    "google-gemini-2.5-pro",
+    "anthropic-claude-4-sonnet-thinking",
+    "anthropic-claude-4-opus",
+    "anthropic-claude-4-sonnet",
+    "openai-gpt-4.1",
+    "openai-gpt-o1",
+    "openai-gpt-4o"
+];
+
+// Simple mapping for common OpenAI names to Tau names if needed
+const MODEL_MAP: Record<string, string> = {
+    "gpt-4o": "openai-gpt-4o",
+    "gpt-4": "openai-gpt-4.1", // Example mapping based on Tau's listed names
+    "gpt-3.5-turbo": "openai-gpt-o1", // Example mapping
+    "claude-3-opus-20240229": "anthropic-claude-4-opus",
+    "claude-3-sonnet-20240229": "anthropic-claude-4-sonnet",
+    // Add more mappings if clients use different names
+};
+
+// Read Tau API Key from environment variable
+const TAU_API_KEY = Deno.env.get("TAU_API_KEY");
+if (!TAU_API_KEY) {
+    console.warn("TAU_API_KEY environment variable is not set. Requests to Tau API might fail if authentication is required.");
+}
+
+
+// --- Helper Functions ---
+
+/** Generates a UUID with a prefix for OpenAI-like IDs */
+function generateId(prefix: string = ""): string {
+    return `${prefix}${crypto.randomUUID().replace(/-/g, '')}`;
+}
+
+/** Generates a current timestamp in seconds */
+function getCurrentTimestamp(): number {
+    return Math.floor(Date.now() / 1000);
+}
+
+/** Parses a Tau API stream line, cleaning content from 0: and g: prefixes. */
+function parseTauStreamLine(line: string): { prefix: string | null, content: string } {
+    console.debug(`Raw stream line received: "${line.replace(/\n/g, "\\n").replace(/\r/g, "\\r")}"`);
+
+    const colonIndex = line.indexOf(':');
+    if (colonIndex === -1) {
+         console.warn("Stream line missing prefix colon:", line);
+        return { prefix: null, content: line };
+    }
+    const prefix = line.substring(0, colonIndex);
+    let content = line.substring(colonIndex + 1);
+
+    // --- Cleaning Logic for 0: and g: content ---
+    if (prefix === '0' || prefix === 'g') {
+        // Check if content is wrapped in an extra pair of quotes, as observed
+        if (content.startsWith('"') && content.endsWith('"')) {
+            content = content.substring(1, content.length - 1);
+        }
+        // Replace any occurrences of double double quotes ("") with a single quote (")
+        content = content.replace(/""/g, '"');
+        // The content string *now* contains literal \n characters where they were in the Tau stream.
+    }
+    // --- End Cleaning Logic ---
+
+    console.debug(`Parsed line: Prefix: "${prefix}", Cleaned Content string (contains actual newlines): "${content.replace(/\n/g, "\\n").replace(/\r/g, "\\r")}"`);
+
+    return { prefix, content };
+}
+
+/** Converts Tau API stream line to OpenAI SSE chunk */
+function tauLineToOpenAIChunk(
+    line: string,
+    completionId: string,
+    createdAt: number,
+    model: string
+): { sse: string | null, isDone: boolean, finishReason: string | null, usage: any | null } {
+    const { prefix, content } = parseTauStreamLine(line);
+
+    let delta: any = {};
+    let finishReason: string | null = null;
+    let isDone = false;
+    let usage: any | null = null;
+
+    if (prefix === '0') {
+        delta.content = content; // This is the cleaned string with actual \n characters
+        console.debug(`SSE Chunk (0:): Content string being put into delta: "${content.replace(/\n/g, "\\n").replace(/\r/g, "\\r")}"`);
+    } else if (prefix === 'g') {
+        delta.reasoning_content = content; // This is the cleaned string with actual \n characters
+         console.debug(`SSE Chunk (g:): Reasoning string being put into delta: "${content.replace(/\n/g, "\\n").replace(/\r{/g, "\\r")}"`);
+    } else if (prefix === 'e' || prefix === 'd') {
+        try {
+            const data = JSON.parse(content);
+            if (data.finishReason) {
+                finishReason = data.finishReason;
+                isDone = true;
+                console.debug(`SSE Chunk (e/d:): Found finish reason: ${finishReason}`);
+            }
+            if (data.usage) {
+                 usage = {
+                     prompt_tokens: data.usage.inputTokens || 0,
+                     completion_tokens: data.usage.outputTokens || 0,
+                     total_tokens: (data.usage.inputTokens || 0) + (data.usage.outputTokens || 0),
+                 };
+                 console.debug(`SSE Chunk (e/d:): Found usage: ${JSON.stringify(usage)}`);
+            }
+        } catch (e) {
+            console.error("Failed to parse JSON from e/d prefix:", content, e);
+        }
+    } else if (prefix === '8') {
+         try {
+              const data = JSON.parse(content);
+              if (data.usageCost && data.usageTokens) {
+                  usage = {
+                      prompt_tokens: data.usageTokens.inputTokens || 0,
+                      completion_tokens: data.usageTokens.outputTokens || 0,
+                      total_tokens: (data.usageTokens.inputTokens || 0) + (data.usageTokens.outputTokens || 0),
+                  };
+                  console.debug(`SSE Chunk (8:): Found usage: ${JSON.stringify(usage)}`);
+              }
+         } catch (e) {
+            console.error("Failed to parse JSON from 8 prefix:", content, e);
+         }
+    } else if (prefix === null) {
+         return { sse: null, isDone: false, finishReason: null, usage: null };
+    } else {
+        console.warn("Received unknown Tau stream prefix:", prefix, "content:", content);
+        return { sse: null, isDone: false, finishReason: null, usage: null };
+    }
+
+    if (Object.keys(delta).length === 0 && !finishReason && !usage) {
+         return { sse: null, isDone: false, finishReason: null, usage: null };
+    }
+
+    const chunk: any = {
+        id: completionId,
+        object: "chat.completion.chunk",
+        created: createdAt,
+        model: model,
+        choices: [{
+            index: 0,
+            delta: delta, // delta now contains the cleaned string with actual newlines
+            logprobs: null,
+            finish_reason: finishReason
+        }]
+    };
+
+    // JSON.stringify will automatically escape the actual newlines (\n) in delta strings to \\n
+    const sseData = JSON.stringify(chunk);
+    const sseString = `data: ${sseData}\n\n`;
+
+    // Log the final SSE string *exactly* as it's being sent over the wire
+    console.debug(`SSE Chunk: Final data line being sent: "${sseString.replace(/\n/g, "\\n").replace(/\r/g, "\\r")}"`);
+
+
+    return { sse: sseString, isDone: isDone, finishReason: finishReason, usage: usage };
+}
+
+// --- Endpoint Handlers ---
+
+function handleListModels(): Response {
+    const models = ALLOWED_TAU_MODELS.map(modelName => ({
+        id: modelName,
+        object: "model",
+        created: getCurrentTimestamp(),
+        owned_by: "tau-proxy",
+    }));
+
+    const responseBody = {
+        object: "list",
+        data: models,
+    };
+
+    return new Response(JSON.stringify(responseBody, null, 2), {
+        headers: { "Content-Type": "application/json" },
+        status: 200,
+    });
+}
+
+async function handleChatCompletions(request: Request): Promise<Response> {
+    let reqBody: any;
+    try {
+        reqBody = await request.json();
+    } catch (error) {
+        console.error("Failed to parse request body:", error);;
+        return new Response(JSON.stringify({ error: { message: "Invalid JSON body", type: "invalid_request_error" } }), {
+            status: 400,
+            headers: { "Content-Type": "application/json" },
+        });;
+    }
+
+    if (!Array.isArray(reqBody.messages) || reqBody.messages.length === 0) {
+        return new Response(JSON.stringify({ error: { message: "Request body must contain a non-empty 'messages' array", type: "invalid_request_error" } }), {
+            status: 400,
+            headers: { "Content-Type": "application/json" },
+        });;
+    }
+
+    const clientRequestedModel = reqBody.model;
+    const stream = reqBody.stream === true;
+
+    let tauModel = DEFAULT_TAU_MODEL;
+    if (clientRequestedModel) {
+        const mappedModel = MODEL_MAP[clientRequestedModel];
+        if (mappedModel && ALLOWED_TAU_MODELS.includes(mappedModel)) {
+             tauModel = mappedModel;
+        } else if (ALLOWED_TAU_MODELS.includes(clientRequestedModel)) {
+             tauModel = clientRequestedModel;
+        } else {
+            console.warn(`Client requested model "${clientRequestedModel}" not found in mapping or allowed Tau models. Using default: "${DEFAULT_TAU_MODEL}"`);
+        }
+    } else {
+        console.log(`No model specified by client. Using default: "${DEFAULT_TAU_MODEL}"`);
+    }
+
+
+    let modelAdded = false;
+    const tauRequestMessages = reqBody.messages.map((msg: any) => {
+        const messageId = generateId("msg_");
+        const createdAt = new Date().toISOString();
+        const role = msg.role;
+
+        let parts: any[] = [];
+        if (typeof msg.content === 'string' && msg.content.length > 0) {
+            parts.push({ type: "text", text: msg.content });
+        } else if (Array.isArray(msg.content)) {
+            parts = msg.content.filter((part: any) => part.type === 'text' && part.text && part.text.length > 0).map((part: any) => ({ type: "text", text: part.text }));
+             if (parts.length === 0 && msg.content.length > 0) {
+                 console.warn("Unsupported non-text multimodal content in message:", msg.content);
+             }
+        }
+
+        const tauMessage: any = {
+            id: messageId,
+            content: "", // As per example
+            role: role,
+            parts: parts,
+            metadata: {}, // As per example
+            createdAt: createdAt,
+        };
+
+        if (!modelAdded && role === 'user') {
+             tauMessage.model = tauModel;
+             modelAdded = true;
+             console.log(`Added model ${tauModel} to the first user message.`);
+        } else if (role === 'assistant') {
+            tauMessage.content = typeof msg.content === 'string' ? msg.content : '';
+            tauMessage.parts = [];
+             if (typeof msg.content !== 'string' && msg.content != null) {
+                  console.warn(`Assistant message content is not a string and cannot be mapped to Tau's content field: ${typeof msg.content}`);
+             }
+        }
+
+        return tauMessage;
+    });
+
+    const tauRequestId = generateId("bld_");
+
+    const tauRequestBody = {
+        id: tauRequestId,
+        messages: tauRequestMessages,
+    };
+
+    console.log("Sending request to Tau API:", JSON.stringify(tauRequestBody, null, 2));
+
+    const headers: HeadersInit = {
+        "Content-Type": "application/json",
+    };
+    if (TAU_API_KEY) {
+        headers["Authorization"] = `Bearer ${TAU_API_KEY}`;
+    }
+
+
+    let tauResponse: Response;
+    try {
+        tauResponse = await fetch(TAU_API_URL, {
+            method: "POST",
+            headers: headers,
+            body: JSON.stringify(tauRequestBody),
+        });
+    } catch (error) {
+        console.error("Failed to connect to Tau API:", error);;
+        return new Response(JSON.stringify({ error: { message: `Failed to connect to upstream API: ${error.message}`, type: "upstream_error" } }), {
+            status: 500,
+            headers: { "Content-Type": "application/json" },
+        });;
+    }
+
+    if (!tauResponse.ok) {
+        const errorBody = await tauResponse.text();
+        console.error(`Tau API returned status ${tauResponse.status}: ${errorBody}`);;
+        let errorJson = null;
+        try {
+            errorJson = JSON.parse(errorBody);
+        } catch (e) { /* Not JSON */ }
+
+        return new Response(JSON.stringify({
+            error: {
+                message: `Upstream API error: ${tauResponse.status} - ${errorBody}`,
+                type: "upstream_error",
+                details: errorJson
+            }
+        }), {
+            status: tauResponse.status >= 400 && tauResponse.status < 500 ? 400 : 502,
+            headers: { "Content-Type": "application/json" },
+        });;
+    }
+
+    // --- Handle Tau API Response ---
+
+    const completionId = generateId("chatcmpl-");
+    const createdAt = getCurrentTimestamp();
+
+    if (stream) {
+        // --- Streaming Response ---
+        const reader = tauResponse.body!.getReader();
+        const { readable, writable } = new TransformStream();
+        const writer = writable.getWriter();
+        const encoder = new TextEncoder();
+        const decoder = new TextDecoder();
+
+        async function processStream() {
+            let buffer = "";
+            let finished = false;
+
+            try {
+                while (!finished) {
+                    const { done, value } = await reader.read();
+
+                    if (done) {
+                        finished = true;
+                    } else {
+                        buffer += decoder.decode(value, { stream: true });
+                    }
+
+                    let newlineIndex;
+                    while ((newlineIndex = buffer.indexOf('\n')) !== -1) {
+                        const line = buffer.substring(0, newlineIndex);
+                        buffer = buffer.substring(newlineIndex + 1);
+
+                        if (line.trim() === "") continue;
+                        // parseTauStreamLine logs raw line and cleaned content
+
+                        const { sse, isDone, finishReason, usage } = tauLineToOpenAIChunk(line, completionId, createdAt, tauModel);
+
+                        if (sse) {
+                           await writer.write(encoder.encode(sse));
+                        }
+
+                        if (isDone) {
+                             finished = true;
+                         }
+                    }
+
+                    if (finished && buffer.length > 0) {
+                        console.warn("Processing leftover buffer after stream end:", buffer);;
+                         const { sse, isDone: lastIsDone, finishReason: lastFinishReason, usage: lastChunkUsage } = tauLineToOpenAIChunk(buffer, completionId, createdAt, tauModel);
+                         if (sse) {
+                            await writer.write(encoder.encode(sse));
+                         }
+                         finished = finished || lastIsDone;
+                         buffer = "";
+                    }
+                }
+            } catch (error) {
+                console.error("Stream processing error:", error);;
+                try {
+                    await writer.write(encoder.encode(`data: ${JSON.stringify({ error: { message: `Stream error: ${error.message}`, type: "stream_error" } })}\n\n`));
+                } catch (writeError) { console.error("Failed to write error message:", writeError);; }
+            } finally {
+                 try {
+                     await writer.write(encoder.encode("data: [DONE]\n\n"));
+                     await writer.close();
+                 } catch (closeError) { console.error("Failed to send DONE or close stream:", closeError);; }
+            }
+        }
+
+        processStream();
+
+        return new Response(readable, {
+            headers: {
+                "Content-Type": "text/event-stream",
+                "Cache-Control": "no-cache",
+                "Connection": "keep-alive",
+            },
+        });;
+
+    } else {
+        // --- Non-Streaming Response ---
+        let buffer = "";
+        const reader = tauResponse.body!.getReader();
+        const decoder = new TextDecoder();
+
+        let combinedContent = "";
+        let combinedReasoningContent = "";
+        let finishReason: string | null = null;
+        let usageData: any | null = null;
+
+        try {
+            while (true) {
+                const { done, value } = await reader.read();
+                buffer += decoder.decode(value, { stream: !done });
+
+                if (done) {
+                    break;
+                }
+
+                let newlineIndex;
+                while ((newlineIndex = buffer.indexOf('\n')) !== -1) {
+                    const line = buffer.substring(0, newlineIndex);
+                    buffer = buffer.substring(newlineIndex + 1);
+
+                    if (line.trim() === "") continue;
+                    // parseTauStreamLine logs raw line and cleaned content
+
+                    const { prefix, content } = parseTauStreamLine(line);
+
+                    if (prefix === '0') {
+                         combinedContent += content; // Use the cleaned content
+                         console.debug(`Non-stream: Appended to combinedContent string: "${content.replace(/\n/g, "\\n").replace(/\r/g, "\\r")}"`);
+                    } else if (prefix === 'g') {
+                         combinedReasoningContent += content; // Use the cleaned content
+                         console.debug(`Non-stream: Appended to combinedReasoningContent string: "${content.replace(/\n/g, "\\n").replace(/\r/g, "\\r")}"`);
+                    } else if (prefix === 'e' || prefix === 'd') {
+                        try {
+                             const data = JSON.parse(content);
+                             if (data.finishReason) {
+                                 finishReason = data.finishReason;
+                                 console.debug(`Non-stream: Found finish reason: ${finishReason}`);
+                             }
+                             if (data.usage) {
+                                usageData = {
+                                    prompt_tokens: data.usage.inputTokens || 0,
+                                    completion_tokens: data.usage.outputTokens || 0,
+                                    total_tokens: (data.usage.inputTokens || 0) + (data.usage.outputTokens || 0),
+                                };
+                                console.debug(`Non-stream: Found usage (e/d): ${JSON.stringify(usageData)}`);
+                             }
+                        } catch (e) {
+                            console.error("Failed to parse JSON from e/d prefix (non-stream):", content, e);;
+                        }
+                    } else if (prefix === '8') {
+                         try {
+                              const data = JSON.parse(content);
+                              if (data.usageCost && data.usageTokens) {
+                                  usageData = {
+                                      prompt_tokens: data.usageTokens.inputTokens || 0,
+                                      completion_tokens: data.usageTokens.outputTokens || 0,
+                                      total_tokens: (data.usageTokens.inputTokens || 0) + (data.usageTokens.outputTokens || 0),
+                                  };
+                                   console.debug(`Non-stream: Found usage (8): ${JSON.stringify(usageData)}`);
+                              }
+                         } catch (e) {
+                            console.error("Failed to parse JSON from 8 prefix (non-stream):", content, e);;
+                         }
+                    } else if (prefix === null) {
+                         console.warn("Ignoring non-stream line with no prefix:", line);
+                    } else {
+                        console.warn("Received unknown Tau non-stream prefix:", prefix, "content:", content);
+                    }
+                }
+            }
+        } catch (error) {
+            console.error("Error reading Tau API response (non-stream):", error);;
+            return new Response(JSON.stringify({ error: { message: `Error processing upstream response: ${error.message}`, type: "upstream_error" } }), {
+                status: 500,
+                headers: { "Content-Type": "application/json" },
+            });;
+        }
+
+         // Process any remaining buffer after the loop
+        if (buffer.length > 0) {
+             console.warn("Non-stream buffer leftover:", buffer);;
+             const lines = buffer.split('\n');
+             for(const line of lines) {
+                if (line.trim() === "") continue;
+                 const { prefix, content } = parseTauStreamLine(line);
+                 if (prefix === '0') {
+                     combinedContent += content; // Use the cleaned content
+                      console.debug(`Non-stream: Appended leftover to combinedContent string: "${content.replace(/\n/g, "\\n").replace(/\r/g, "\\r")}"`);
+                 } else if (prefix === 'g') {
+                     combinedReasoningContent += content; // Use the cleaned content
+                      console.debug(`Non-stream: Appended leftover to combinedReasoningContent string: "${content.replace(/\n/g, "\\n").replace(/\r/g, "\\r")}"`);
+                 } else if (prefix === 'e' || prefix === 'd') {
+                      try {
+                         const data = JSON.parse(content);
+                         if (data.finishReason) finishReason = data.finishReason;
+                         if (data.usage) usageData = { prompt_tokens: data.usage.inputTokens || 0, completion_tokens: data.usage.completionTokens || 0, total_tokens: (data.usage.inputTokens || 0) + (data.usage.completionTokens || 0) };
+                          console.debug(`Non-stream: Found leftover usage/finish (e/d): ${JSON.stringify(usageData || { finishReason })}`);
+                      } catch (e) { console.warn("Failed to parse leftover e/d:", buffer);; }
+                 } else if (prefix === '8') {
+                      try {
+                           const data = JSON.parse(content);
+                           if (data.usageCost && data.usageTokens) { usageData = { prompt_tokens: data.usageTokens.inputTokens || 0, completion_tokens: data.usageTokens.outputTokens || 0, total_tokens: (data.usageTokens.inputTokens || 0) + (data.usageTokens.outputTokens || 0) }; }
+                            console.debug(`Non-stream: Found leftover usage (8): ${JSON.stringify(usageData)}`);
+                      } catch (e) { console.warn("Failed to parse leftover 8:", buffer);; }
+                 } else if (prefix === null) {
+                      console.warn("Ignoring leftover non-stream line with no prefix:", line);
+                 } else {
+                      console.warn("Received unknown Tau non-stream leftover prefix:", prefix, "content:", content);
+                 }
+             }
+        }
+
+        // Log the final combined string content *before* it's JSON.stringify-ed
+        console.debug("Non-Stream: Final combinedContent string before JSON.stringify:", `"${combinedContent.replace(/\n/g, "\\n").replace(/\r/g, "\\r")}"`);
+        console.debug("Non-Stream: Final combinedReasoningContent string before JSON.stringify:", `"${combinedReasoningContent.replace(/\n/g, "\\n").replace(/\r/g, "\\r")}"`);
+
+
+        const responseJson: any = {
+            id: completionId,
+            object: "chat.completion",
+            created: createdAt,
+            model: tauModel,
+            choices: [{
+                index: 0,
+                message: {
+                    role: "assistant",
+                    content: combinedContent, // Use the combined, cleaned string
+                },
+                logprobs: null,
+                finish_reason: finishReason,
+            }],
+            usage: usageData ? {
+                 prompt_tokens: usageData.prompt_tokens,
+                 completion_tokens: usageData.completion_tokens,
+                 total_tokens: usageData.prompt_tokens + usageData.completion_tokens,
+            } : { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 },
+            system_fingerprint: "tau_api_proxy",
+        };;
+
+        console.debug("Final Non-Stream Response Body (after JSON.stringify):", JSON.stringify(responseJson, null, 2));
+
+        return new Response(JSON.stringify(responseJson, null, 2), {
+            headers: { "Content-Type": "application/json" },
+        });;
+    }
+}
+
+
+// --- Main Request Handler Dispatcher ---
+
+async function handler(request: Request): Promise<Response> {
+    const url = new URL(request.url);
+    const path = url.pathname;
+    const method = request.method;
+
+    console.log(`Received request: ${method} ${path}`);;
+
+    if (method === "GET" && path === "/v1/models") {
+        return handleListModels();;
+    } else if (method === "POST" && path === "/v1/chat/completions") {
+        return handleChatCompletions(request);;
+    } else {
+        return new Response("Not Found", { status: 404 });;
+    }
+}
+
+
+// --- Start Server ---
+const PORT = 8000;
+console.log(`Listening on http://localhost:${PORT}/`);;
+Deno.serve({ port: PORT }, handler);;