мяу

Dockerfile

@@ -1,64 +1,20 @@
-# Build stage - install dependencies and prepare source
-FROM oven/bun:1.2.14-alpine AS build
+FROM oven/bun:latest
 
 WORKDIR /app
 
-# Copy package files
-COPY package.json bun.lock* ./
+# Копируем всё содержимое папки duckai в /app
+COPY . .
 
-# Install all dependencies
-RUN bun install --frozen-lockfile
+# Устанавливаем зависимости
+RUN bun install
 
-# Copy source code
-COPY . ./
+# Проверяем, где лежит server.ts (на всякий случай для логов HF)
+RUN ls -R
 
-# Production stage - minimal Bun runtime
-FROM oven/bun:1.2.14-alpine AS production
+# Открываем порт
+EXPOSE 7860
 
-# Install essential runtime dependencies
-RUN apk add --no-cache \
-    ca-certificates \
-    curl \
-    && rm -rf /var/cache/apk/*
-
-# The bun user already exists in the base image, so we'll use it
-
-# Set working directory
-WORKDIR /app
-
-# Copy package files
-COPY package.json bun.lock* ./
-
-# Install only production dependencies
-RUN bun install --frozen-lockfile --production && \
-    bun pm cache rm
-
-# Copy source code from build stage
-COPY --from=build --chown=bun:bun /app/src ./src
-COPY --from=build --chown=bun:bun /app/tsconfig.json ./tsconfig.json
-COPY --from=build --chown=bun:bun /app/bunfig.toml ./bunfig.toml
-
-# Change ownership of the app directory to the bun user
-RUN chown -R bun:bun /app
-
-# Switch to non-root user
-USER bun
-
-# Expose the port the app runs on
-EXPOSE 3000
-
-# Set environment variables
-ENV NODE_ENV=production
-ENV PORT=3000
-
-# Add labels for better container management
-LABEL maintainer="Duck.ai OpenAI Server"
-LABEL version="1.0.0"
-LABEL description="OpenAI-compatible HTTP server using Duck.ai backend"
-
-# Health check with proper endpoint
-HEALTHCHECK --interval=30s --timeout=10s --start-period=40s --retries=3 \
-  CMD curl -f http://localhost:3000/health || exit 1
-
-# Start the application with Bun runtime
-CMD ["bun", "run", "src/server.ts"] 
+# Запускаем сервер. 
+# Если ты загрузил файлы из папки src, то путь будет src/server.ts
+# Если ты загрузил файлы без папки src, то просто server.ts
+CMD ["bun", "run", "src/server.ts"]

README.md

@@ -1,250 +1,12 @@
-# DuckAI OpenAI Server
-
-A high-performance OpenAI-compatible HTTP server that uses DuckDuckGo's AI backend, providing free access to multiple AI models through the familiar OpenAI API interface.
-
-## Setup & Quick Start
-
-### Option 1: Using Docker (Recommended)
-
-The easiest way to get started is using the pre-built Docker image:
-
-```bash
-# Pull the Docker image
-docker pull amirkabiri/duckai
-
-# Run the container
-docker run -p 3000:3000 amirkabiri/duckai
-```
-
-The server will be available at `http://localhost:3000`.
-
-Docker image URL: [https://hub.docker.com/r/amirkabiri/duckai/](https://hub.docker.com/r/amirkabiri/duckai/)
-
-### Option 2: Manual Setup
-
-1. Clone the repository:
-```bash
-git clone git@github.com:amirkabiri/duckai.git
-cd duckai
-```
-
-2. Install dependencies:
-```bash
-bun install
-```
-
-3. Start the server:
-```bash
-bun run dev
-```
-
-### Basic Usage Example
-
-```javascript
-import OpenAI from "openai";
-
-const openai = new OpenAI({
-  baseURL: "http://localhost:3000/v1",
-  apiKey: "dummy-key", // Any string works
-});
-
-// Chat completion
-const completion = await openai.chat.completions.create({
-  model: "gpt-4o-mini", // Default model
-  messages: [
-    { role: "user", content: "Hello! How are you?" }
-  ],
-});
-
-console.log(completion.choices[0].message.content);
-```
-
-## Introduction
-
-DuckAI OpenAI Server bridges the gap between DuckDuckGo's free AI chat service and the widely-adopted OpenAI API format. This allows you to:
-
-- **Use multiple AI models for free** - Access GPT-4o-mini, Claude-3-Haiku, Llama-3.3-70B, and more
-- **Drop-in OpenAI replacement** - Compatible with existing OpenAI client libraries
-- **Tool calling support** - Full function calling capabilities
-- **Streaming responses** - Real-time response streaming
-- ✅ Rate limiting - Built-in intelligent rate limiting to respect DuckDuckGo's limits
-
-### Supported Models
-
-- `gpt-4o-mini` (Default)
-- `gpt-5-mini`
-- `claude-3-5-haiku-latest`
-- `meta-llama/Llama-4-Scout-17B-16E-Instruct`
-- `mistralai/Mistral-Small-24B-Instruct-2501`
-- `openai/gpt-oss-120b`
-
-### Features
-
-- ✅ Chat completions
-- ✅ Streaming responses
-- ✅ Function/tool calling
-- ✅ Multiple model support
-- ✅ Rate limiting with intelligent backoff
-- ✅ OpenAI-compatible error handling
-- ✅ CORS support
-- ✅ Health check endpoint
-
-## Usage
-
-### Prerequisites
-
-- [Bun](https://bun.sh/) runtime (recommended) or Node.js 18+
-
-### Installation
-
-1. Clone the repository:
-```bash
-git clone git@github.com:amirkabiri/duckai.git
-cd duckai
-```
-
-2. Install dependencies:
-```bash
-bun install
-```
-
-3. Start the server:
-```bash
-bun run dev
-```
-
-The server will start on `http://localhost:3000` by default.
-
-### Basic Usage
-
-#### Using with OpenAI JavaScript Library
-
-```javascript
-import OpenAI from "openai";
-
-const openai = new OpenAI({
-  baseURL: "http://localhost:3000/v1",
-  apiKey: "dummy-key", // Any string works
-});
-
-// Basic chat completion
-const completion = await openai.chat.completions.create({
-  model: "gpt-4o-mini",
-  messages: [
-    { role: "user", content: "Hello! How are you?" }
-  ],
-});
-
-console.log(completion.choices[0].message.content);
-```
-
-#### Tool Calling Example
-
-```javascript
-const tools = [
-  {
-    type: "function",
-    function: {
-      name: "calculate",
-      description: "Perform mathematical calculations",
-      parameters: {
-        type: "object",
-        properties: {
-          expression: {
-            type: "string",
-            description: "Mathematical expression to evaluate"
-          }
-        },
-        required: ["expression"]
-      }
-    }
-  }
-];
-
-const completion = await openai.chat.completions.create({
-  model: "gpt-4o-mini",
-  messages: [
-    { role: "user", content: "What is 15 * 8?" }
-  ],
-  tools: tools,
-  tool_choice: "auto"
-});
-
-// The AI will call the calculate function
-console.log(completion.choices[0].message.tool_calls);
-```
-
-#### Streaming Responses
-
-```javascript
-const stream = await openai.chat.completions.create({
-  model: "gpt-4o-mini",
-  messages: [
-    { role: "user", content: "Tell me a story" }
-  ],
-  stream: true
-});
-
-for await (const chunk of stream) {
-  const content = chunk.choices[0]?.delta?.content;
-  if (content) {
-    process.stdout.write(content);
-  }
-}
-```
-
-#### Using with curl
-
-```bash
-curl -X POST http://localhost:3000/v1/chat/completions \
-  -H "Content-Type: application/json" \
-  -H "Authorization: Bearer dummy-key" \
-  -d '{
-    "model": "gpt-4o-mini",
-    "messages": [
-      {"role": "user", "content": "Hello!"}
-    ]
-  }'
-```
-
-### API Endpoints
-
-- `POST /v1/chat/completions` - Chat completions (compatible with OpenAI)
-- `GET /v1/models` - List available models
-- `GET /health` - Health check endpoint
-
-### Environment Variables
-
-- `PORT` - Server port (default: 3000)
-- `HOST` - Server host (default: 0.0.0.0)
-
-## Usage with Docker
-
-### Building the Docker Image
-
-```bash
-docker build -t duckai .
-```
-
-### Running with Docker
-
-```bash
-docker run -p 3000:3000 duckai
-```
-
-## Contributing
-
-1. Fork the repository
-2. Create a feature branch
-3. Make your changes
-4. Add tests for new functionality
-5. Run the test suite
-6. Submit a pull request
-
-## License
-
-MIT License - see LICENSE file for details.
-
-## Disclaimer
-
-This project is not affiliated with DuckDuckGo or OpenAI. It's an unofficial bridge service for educational and development purposes. Please respect DuckDuckGo's terms of service and rate limits.
+---
+title: DuckAI
+sdk: docker
+emoji: 🦀
+colorFrom: blue
+colorTo: green
+app_port: 7860
+license: mit
+---
+
+# DuckAI Proxy Server
+Running on port 7860

bun.lock

@@ -1,5 +1,6 @@
 {
   "lockfileVersion": 1,
+  "configVersion": 0,
   "workspaces": {
     "": {
       "name": "duckai-openai-server",

quick-test.ts

@@ -0,0 +1,17 @@
+import { DuckAI } from "./src/duckai";
+
+async function test() {
+  console.log("Testing DuckAI direct connection...");
+  const duckai = new DuckAI();
+  try {
+    const response = await duckai.chat({
+      model: "gpt-4o-mini",
+      messages: [{ role: "user", content: "Say 'Success!'" }]
+    });
+    console.log("Response:", response);
+  } catch (error) {
+    console.error("Test failed:", error);
+  }
+}
+
+test();

src/duckai.ts

@@ -221,43 +221,58 @@ export class DuckAI {
   }
 
   private async getVQD(userAgent: string): Promise<VQDResponse> {
-    const response = await fetch("https://duckduckgo.com/duckchat/v1/status", {
-      headers: {
-        accept: "*/*",
-        "accept-language": "en-US,en;q=0.9,fa;q=0.8",
-        "cache-control": "no-store",
-        pragma: "no-cache",
-        priority: "u=1, i",
-        "sec-fetch-dest": "empty",
-        "sec-fetch-mode": "cors",
-        "sec-fetch-site": "same-origin",
-        "x-vqd-accept": "1",
-        "User-Agent": userAgent,
-      },
-      referrer: "https://duckduckgo.com/",
-      referrerPolicy: "origin",
-      method: "GET",
-      mode: "cors",
-      credentials: "include",
-    });
+    // Create AbortController with timeout for fetch
+    const vqdController = new AbortController();
+    const vqdTimeoutId = setTimeout(() => vqdController.abort(), 10000); // 10 second timeout for VQD
 
-    if (!response.ok) {
-      throw new Error(
-        `Failed to get VQD: ${response.status} ${response.statusText}`
-      );
-    }
+    try {
+      const response = await fetch("https://duckduckgo.com/duckchat/v1/status", {
+        headers: {
+          accept: "*/*",
+          "accept-language": "en-US,en;q=0.9,fa;q=0.8",
+          "cache-control": "no-store",
+          pragma: "no-cache",
+          priority: "u=1, i",
+          "sec-fetch-dest": "empty",
+          "sec-fetch-mode": "cors",
+          "sec-fetch-site": "same-origin",
+          "x-vqd-accept": "1",
+          "User-Agent": userAgent,
+        },
+        referrer: "https://duckduckgo.com/",
+        referrerPolicy: "origin",
+        method: "GET",
+        mode: "cors",
+        credentials: "include",
+        signal: vqdController.signal,
+      });
+
+      clearTimeout(vqdTimeoutId);
+
+      if (!response.ok) {
+        throw new Error(
+          `Failed to get VQD: ${response.status} ${response.statusText}`
+        );
+      }
 
-    const hashHeader = response.headers.get("x-Vqd-hash-1");
+      const hashHeader = response.headers.get("x-Vqd-hash-1");
 
-    if (!hashHeader) {
-      throw new Error(
-        `Missing VQD headers: hash=${!!hashHeader}`
-      );
-    }
+      if (!hashHeader) {
+        throw new Error(
+          `Missing VQD headers: hash=${!!hashHeader}`
+        );
+      }
 
-    const encodedHash = await this.getEncodedVqdHash(hashHeader);
+      const encodedHash = await this.getEncodedVqdHash(hashHeader);
 
-    return { hash: encodedHash };
+      return { hash: encodedHash };
+    } catch (error) {
+      clearTimeout(vqdTimeoutId);
+      if (error instanceof Error && error.name === "AbortError") {
+        throw new Error("VQD request timeout - took longer than 10 seconds");
+      }
+      throw error;
+    }
   }
 
   private async hashClientHashes(clientHashes: string[]): Promise<string[]> {
@@ -290,81 +305,101 @@ export class DuckAI {
     // Show compact rate limit status in server console
     this.rateLimitMonitor.printCompactStatus();
 
-    const response = await fetch("https://duckduckgo.com/duckchat/v1/chat", {
-      headers: {
-        accept: "text/event-stream",
-        "accept-language": "en-US,en;q=0.9,fa;q=0.8",
-        "cache-control": "no-cache",
-        "content-type": "application/json",
-        pragma: "no-cache",
-        priority: "u=1, i",
-        "sec-fetch-dest": "empty",
-        "sec-fetch-mode": "cors",
-        "sec-fetch-site": "same-origin",
-        "x-fe-version": "serp_20250401_100419_ET-19d438eb199b2bf7c300",
-        "User-Agent": userAgent,
-        "x-vqd-hash-1": vqd.hash,
-      },
-      referrer: "https://duckduckgo.com/",
-      referrerPolicy: "origin",
-      body: JSON.stringify(request),
-      method: "POST",
-      mode: "cors",
-      credentials: "include",
-    });
+    // Create AbortController with timeout for fetch
+    const fetchController = new AbortController();
+    const timeoutId = setTimeout(() => fetchController.abort(), 30000); // 30 second timeout
 
-    // Handle rate limiting
-    if (response.status === 429) {
-      const retryAfter = response.headers.get("retry-after");
-      const waitTime = retryAfter ? parseInt(retryAfter) * 1000 : 60000; // Default 1 minute
-      throw new Error(
-        `Rate limited. Retry after ${waitTime}ms. Status: ${response.status}`
-      );
-    }
+    try {
+      // Log the request being sent for debugging
+      console.log("Sending DuckAI request:", JSON.stringify(request, null, 2));
+
+      const response = await fetch("https://duckduckgo.com/duckchat/v1/chat", {
+        headers: {
+          accept: "text/event-stream",
+          "accept-language": "en-US,en;q=0.9,fa;q=0.8",
+          "cache-control": "no-cache",
+          "content-type": "application/json",
+          pragma: "no-cache",
+          priority: "u=1, i",
+          "sec-fetch-dest": "empty",
+          "sec-fetch-mode": "cors",
+          "sec-fetch-site": "same-origin",
+          "x-fe-version": "serp_20250401_100419_ET-19d438eb199b2bf7c300",
+          "User-Agent": userAgent,
+          "x-vqd-hash-1": vqd.hash,
+        },
+        referrer: "https://duckduckgo.com/",
+        referrerPolicy: "origin",
+        body: JSON.stringify(request),
+        method: "POST",
+        mode: "cors",
+        credentials: "include",
+        signal: fetchController.signal,
+      });
+
+      clearTimeout(timeoutId);
+
+      // Handle rate limiting
+      if (response.status === 429) {
+        const retryAfter = response.headers.get("retry-after");
+        const waitTime = retryAfter ? parseInt(retryAfter) * 1000 : 60000; // Default 1 minute
+        throw new Error(
+          `Rate limited. Retry after ${waitTime}ms. Status: ${response.status}`
+        );
+      }
 
-    if (!response.ok) {
-      throw new Error(
-        `DuckAI API error: ${response.status} ${response.statusText}`
-      );
-    }
+      if (!response.ok) {
+        const responseText = await response.text();
+        console.error(`DuckAI API error ${response.status}:`, responseText);
+        throw new Error(
+          `DuckAI API error: ${response.status} ${response.statusText} - ${responseText}`
+        );
+      }
 
-    const text = await response.text();
+      const text = await response.text();
 
-    // Check for errors
-    try {
-      const parsed = JSON.parse(text);
-      if (parsed.action === "error") {
-        throw new Error(`Duck.ai error: ${JSON.stringify(parsed)}`);
+      // Check for errors
+      try {
+        const parsed = JSON.parse(text);
+        if (parsed.action === "error") {
+          throw new Error(`Duck.ai error: ${JSON.stringify(parsed)}`);
+        }
+      } catch (e) {
+        // Not JSON, continue processing
       }
-    } catch (e) {
-      // Not JSON, continue processing
-    }
 
-    // Extract the LLM response from the streamed response
-    let llmResponse = "";
-    const lines = text.split("\n");
-    for (const line of lines) {
-      if (line.startsWith("data: ")) {
-        try {
-          const json = JSON.parse(line.slice(6));
-          if (json.message) {
-            llmResponse += json.message;
+      // Extract the LLM response from the streamed response
+      let llmResponse = "";
+      const lines = text.split("\n");
+      for (const line of lines) {
+        if (line.startsWith("data: ")) {
+          try {
+            const json = JSON.parse(line.slice(6));
+            if (json.message) {
+              llmResponse += json.message;
+            }
+          } catch (e) {
+            // Skip invalid JSON lines
           }
-        } catch (e) {
-          // Skip invalid JSON lines
         }
       }
-    }
 
-    const finalResponse = llmResponse.trim();
+      const finalResponse = llmResponse.trim();
 
-    // If response is empty, provide a fallback
-    if (!finalResponse) {
-      console.warn("Duck.ai returned empty response, using fallback");
-      return "I apologize, but I'm unable to provide a response at the moment. Please try again.";
-    }
+      // If response is empty, provide a fallback
+      if (!finalResponse) {
+        console.warn("Duck.ai returned empty response, using fallback");
+        return "I apologize, but I'm unable to provide a response at the moment. Please try again.";
+      }
 
-    return finalResponse;
+      return finalResponse;
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (error instanceof Error && error.name === "AbortError") {
+        throw new Error("DuckAI API request timeout - took longer than 30 seconds");
+      }
+      throw error;
+    }
   }
 
   async chatStream(request: DuckAIRequest): Promise<ReadableStream<string>> {

src/openai-service.ts

@@ -72,12 +72,49 @@ export class OpenAIService {
   private transformToDuckAIRequest(
     request: ChatCompletionRequest
   ): DuckAIRequest {
-    // Use the model from request, fallback to default
-    const model = request.model || "mistralai/Mistral-Small-24B-Instruct-2501";
+    // DuckDuckGo doesn't support system messages, so combine them with first user message
+    // Also, only send role and content - DuckDuckGo rejects extra fields
+    const transformedMessages = [];
+    let systemContent = "";
+    let firstUserMessageProcessed = false;
 
+    for (const message of request.messages) {
+      if (message.role === "system") {
+        systemContent += (systemContent ? "\n" : "") + message.content;
+      } else if (message.role === "user") {
+        // Prepend system message to the first user message
+        const userContent = !firstUserMessageProcessed && systemContent 
+          ? systemContent + "\n\n" + message.content 
+          : message.content;
+        
+        transformedMessages.push({
+          role: "user",
+          content: userContent,
+        });
+        firstUserMessageProcessed = true;
+      } else if (message.role === "assistant") {
+        // Only send role and content for assistant messages
+        transformedMessages.push({
+          role: "assistant",
+          content: message.content || "",
+        });
+      }
+    }
+
+    // If we have system content but no user messages yet, prepend to a dummy user message
+    if (!firstUserMessageProcessed && systemContent) {
+      transformedMessages.push({
+        role: "user",
+        content: systemContent,
+      });
+    }
+
+    // DuckDuckGo REQUIRES the model field
+    const model = request.model || "gpt-4o-mini";
+    
     return {
       model,
-      messages: request.messages,
+      messages: transformedMessages,
     };
   }
 

src/server.ts

@@ -2,105 +2,115 @@ import { OpenAIService } from "./openai-service";
 
 const openAIService = new OpenAIService();
 
-const server = Bun.serve({
-  port: process.env.PORT || 3000,
-  async fetch(req) {
-    const url = new URL(req.url);
-
-    // CORS headers
-    const corsHeaders = {
-      "Access-Control-Allow-Origin": "*",
-      "Access-Control-Allow-Methods": "GET, POST, OPTIONS",
-      "Access-Control-Allow-Headers": "Content-Type, Authorization",
-    };
+process.on('uncaughtException', (error) => {
+  console.error('Uncaught Exception:', error);
+  process.exit(1);
+});
 
-    // Handle preflight requests
-    if (req.method === "OPTIONS") {
-      return new Response(null, { headers: corsHeaders });
-    }
+process.on('unhandledRejection', (reason, promise) => {
+  console.error('Unhandled Rejection at:', promise, 'reason:', reason);
+  process.exit(1);
+});
 
-    try {
-      // Health check endpoint
-      if (url.pathname === "/health" && req.method === "GET") {
-        return new Response(JSON.stringify({ status: "ok" }), {
-          headers: { "Content-Type": "application/json", ...corsHeaders },
-        });
-      }
+try {
+  const server = Bun.serve({
+    port: process.env.PORT || 7860,
+    async fetch(req) {
+    console.log(`Received request: ${req.method} ${req.url}`);
+    const url = new URL(req.url);
+      const corsHeaders = {
+        "Access-Control-Allow-Origin": "*",
+        "Access-Control-Allow-Methods": "GET, POST, OPTIONS",
+        "Access-Control-Allow-Headers": "Content-Type, Authorization",
+      };
 
-      // Models endpoint
-      if (url.pathname === "/v1/models" && req.method === "GET") {
-        const models = openAIService.getModels();
-        return new Response(JSON.stringify(models), {
-          headers: { "Content-Type": "application/json", ...corsHeaders },
-        });
+      // Handle preflight requests
+      if (req.method === "OPTIONS") {
+        return new Response(null, { headers: corsHeaders });
       }
 
-      // Chat completions endpoint
-      if (url.pathname === "/v1/chat/completions" && req.method === "POST") {
-        const body = await req.json();
-        const validatedRequest = openAIService.validateRequest(body);
+      try {
+        // Health check endpoint
+        if (url.pathname === "/health" && req.method === "GET") {
+          return new Response(JSON.stringify({ status: "ok" }), {
+            headers: { "Content-Type": "application/json", ...corsHeaders },
+          });
+        }
 
-        // Handle streaming
-        if (validatedRequest.stream) {
-          const stream =
-            await openAIService.createChatCompletionStream(validatedRequest);
-          return new Response(stream, {
-            headers: {
-              "Content-Type": "text/event-stream",
-              "Cache-Control": "no-cache",
-              Connection: "keep-alive",
-              ...corsHeaders,
-            },
+        // Models endpoint
+        if (url.pathname === "/v1/models" && req.method === "GET") {
+          const models = openAIService.getModels();
+          return new Response(JSON.stringify(models), {
+            headers: { "Content-Type": "application/json", ...corsHeaders },
           });
         }
 
-        // Handle non-streaming
-        const completion =
-          await openAIService.createChatCompletion(validatedRequest);
-        return new Response(JSON.stringify(completion), {
-          headers: { "Content-Type": "application/json", ...corsHeaders },
-        });
-      }
+        // Chat completions endpoint
+        if (url.pathname === "/v1/chat/completions" && req.method === "POST") {
+          const body = await req.json();
+          const validatedRequest = openAIService.validateRequest(body);
+
+          // Handle streaming
+          if (validatedRequest.stream) {
+            const stream =
+              await openAIService.createChatCompletionStream(validatedRequest);
+            return new Response(stream, {
+              headers: {
+                "Content-Type": "text/event-stream",
+                "Cache-Control": "no-cache",
+                Connection: "keep-alive",
+                ...corsHeaders,
+              },
+            });
+          }
 
-      // 404 for unknown endpoints
-      return new Response(
-        JSON.stringify({
-          error: {
-            message: "Not found",
-            type: "invalid_request_error",
-          },
-        }),
-        {
-          status: 404,
-          headers: { "Content-Type": "application/json", ...corsHeaders },
+          // Handle non-streaming
+          const completion =
+            await openAIService.createChatCompletion(validatedRequest);
+          return new Response(JSON.stringify(completion), {
+            headers: { "Content-Type": "application/json", ...corsHeaders },
+          });
         }
-      );
-    } catch (error) {
-      console.error("Server error:", error);
 
-      const errorMessage =
-        error instanceof Error ? error.message : "Internal server error";
-      const statusCode =
-        errorMessage.includes("required") || errorMessage.includes("must")
-          ? 400
-          : 500;
+        // 404 for unknown endpoints
+        return new Response(
+          JSON.stringify({
+            error: {
+              message: "Not found",
+              type: "invalid_request_error",
+            },
+          }),
+          {
+            status: 404,
+            headers: { "Content-Type": "application/json", ...corsHeaders },
+          }
+        );
+      } catch (error) {
+        console.error("Server error:", error);
 
-      return new Response(
-        JSON.stringify({
-          error: {
-            message: errorMessage,
-            type:
-              statusCode === 400
-                ? "invalid_request_error"
-                : "internal_server_error",
-          },
-        }),
-        {
-          status: statusCode,
-          headers: { "Content-Type": "application/json", ...corsHeaders },
-        }
-      );
-    }
+        const errorMessage =
+          error instanceof Error ? error.message : "Internal server error";
+        const statusCode =
+          errorMessage.includes("required") || errorMessage.includes("must")
+            ? 400
+            : 500;
+
+        return new Response(
+          JSON.stringify({
+            error: {
+              message: errorMessage,
+              type:
+                statusCode === 400
+                  ? "invalid_request_error"
+                  : "internal_server_error",
+            },
+          }),
+          {
+            status: statusCode,
+            headers: { "Content-Type": "application/json", ...corsHeaders },
+          }
+        );
+      }
   },
 });
 
@@ -121,3 +131,10 @@ console.log(`  -H "Content-Type: application/json" \\`);
 console.log(
   `  -d '{"model":"gpt-4o-mini","messages":[{"role":"user","content":"Hello!"}]}'`
 );
+
+// Keep the process alive
+// setInterval(() => {}, 1000);
+} catch (error) {
+  console.error("Failed to start server:", error);
+  process.exit(1);
+}

src/types.ts

@@ -106,7 +106,12 @@ export interface VQDResponse {
   hash: string;
 }
 
+export interface DuckAIMessage {
+  role: "user" | "assistant";
+  content: string;
+}
+
 export interface DuckAIRequest {
   model: string;
-  messages: ChatCompletionMessage[];
+  messages: DuckAIMessage[];
 }

test-server.ts

@@ -0,0 +1,8 @@
+const server = Bun.serve({
+  port: 3265,
+  fetch(req) {
+    return new Response("Hello World");
+  }
+});
+
+console.log("Server running on port", server.port);