Upload 17 files

.github/workflows/commitlint.yml

@@ -0,0 +1,13 @@
+name: Lint Commit Messages
+on: [pull_request, push]
+
+permissions:
+  contents: read
+  pull-requests: read
+
+jobs:
+  commitlint:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: wagoid/commitlint-github-action@v6

.github/workflows/deno.yml

@@ -0,0 +1,13 @@
+name: Deno Check
+
+on: [push, pull_request]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: denoland/setup-deno@v1
+      - run: deno fmt --check **/*.ts
+      - run: deno lint
+

.github/workflows/docker.yml

@@ -0,0 +1,33 @@
+name: Build Docker Image
+on:
+  push:
+    tags:
+      - 'v[0-9]+.[0-9]+.[0-9]+'
+  workflow_dispatch:
+
+jobs:
+  docker:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v3
+
+      - name: Set up Docker Buildx
+        id: buildx
+        uses: docker/setup-buildx-action@v3
+
+      - name: Login to DockerHub
+        uses: docker/login-action@v3
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
+
+      - name: Build and push
+        uses: docker/build-push-action@v6
+        with:
+          platforms: linux/amd64,linux/arm64/v8
+          push: true
+          tags: mumulhl/duckduckgo-ai-chat-service:latest

src/api/chat.ts

@@ -0,0 +1,171 @@
+import { Chat, initChat, ModelAlias } from "jsr:@mumulhl/duckduckgo-ai-chat@3";
+import { events } from "jsr:@lukeed/fetch-event-stream";
+
+import { Hono } from "jsr:@hono/hono";
+import { BlankEnv, BlankSchema } from "jsr:@hono/hono/types";
+import { SSEStreamingApi, streamSSE } from "jsr:@hono/hono/streaming";
+
+import * as cache from "./../cache.ts";
+
+type Messages = { content: string; role: "user" | "assistant" | "system" }[];
+
+type MessageData = {
+  id: string;
+  model: string;
+  created: number;
+  role?: "assistant";
+  message?: string;
+};
+
+class DataStream {
+  id: string;
+  model: string;
+  created: number;
+  choices: {
+    delta: { content?: string; role?: "assistant" };
+  }[];
+
+  constructor(messageData: MessageData) {
+    this.id = messageData.id;
+    this.model = messageData.model;
+    this.created = messageData.created;
+    this.choices = [{ delta: { content: messageData.message } }];
+    if (messageData.role === "assistant") {
+      this.choices[0].delta.role = "assistant";
+    }
+  }
+}
+
+async function fetchFull(chat: Chat, messages: Messages) {
+  let message: Response | undefined;
+  let text: string = ""; // Initialize text
+  let messageData: MessageData | undefined;
+
+  for (let i = 0; i < messages.length; i += 2) {
+    text = ""; // Reset the text at each loop to avoid stacking
+    const content = messages[i].content;
+    message = await chat.fetch(content);
+
+    const stream = events(message as Response);
+    for await (const event of stream) {
+      if (!event.data || event.data === "[DONE]") {
+        break; // End the loop if there's no data or received end message
+      }
+
+      try {
+        messageData = JSON.parse(event.data) as MessageData;
+        if (messageData.message === undefined) {
+          break;
+        } else {
+          text += messageData.message; // Append message content
+        }
+      } catch (e) {
+        console.error("Failed to parse JSON:", e);
+        break; // End the loop on parse error
+      }
+    }
+
+    const newVqd = message.headers.get("x-vqd-4") as string;
+    chat.oldVqd = chat.newVqd;
+    chat.newVqd = newVqd;
+
+    chat.messages.push({ content: text, role: "assistant" });
+  }
+
+  const { id, created, model } = messageData as MessageData;
+
+  return { id, created, model, text };
+}
+
+function fetchStream(chat: Chat, messages: Messages) {
+  return async (s: SSEStreamingApi) => {
+    for (let i = 0; i < messages.length; i += 2) {
+      let text = ""; // Reset the text at each loop to avoid stacking
+      let messageData: MessageData | undefined;
+
+      const content = messages[i].content;
+      const message = await chat.fetch(content);
+
+      const stream = events(message as Response);
+
+      for await (const event of stream) {
+        if (!event.data || event.data === "[DONE]") {
+          break; // End the loop if there's no data or received end message
+        }
+
+        try {
+          messageData = JSON.parse(event.data);
+          if (messageData?.message === undefined) {
+            break;
+          } else {
+            text += messageData.message; // Append message content
+          }
+        } catch (e) {
+          console.error("Failed to parse JSON:", e);
+          break; // End the loop on parse error
+        }
+
+        if (i === messages.length - 1) {
+          const dataStream = new DataStream(messageData);
+          await s.writeSSE({
+            data: JSON.stringify(dataStream),
+          });
+        }
+      }
+
+      const newVqd = message.headers.get("x-vqd-4") as string;
+      chat.oldVqd = chat.newVqd;
+      chat.newVqd = newVqd;
+
+      chat.messages.push({ content: text, role: "assistant" });
+    }
+
+    if (chat.messages.length >= 4) {
+      cache.setCache(chat);
+      cache.setRedoCache(chat);
+    }
+  };
+}
+
+function chat(app: Hono<BlankEnv, BlankSchema, "/">) {
+  app.post("/v1/chat/completions", async (c) => {
+    const body = await c.req.json();
+    const stream: boolean = body.stream;
+    const model_name: ModelAlias = body.model;
+    let messages: Messages = body.messages;
+
+    if (messages[0].role === "system") {
+      messages[1].content = messages[0].content + messages[1].content;
+      messages = messages.slice(1);
+    }
+
+    let chat = cache.findCache(messages);
+    if (chat === undefined) {
+      chat = await initChat(model_name);
+    } else {
+      messages = messages.slice(-1);
+    }
+
+    if (stream) {
+      return streamSSE(c, fetchStream(chat, messages));
+    }
+
+    const { id, model, created, text } = await fetchFull(chat, messages);
+
+    if (chat.messages.length >= 4) {
+      cache.setCache(chat);
+      cache.setRedoCache(chat);
+    }
+
+    return c.json({
+      id,
+      model,
+      created,
+      choices: [{
+        message: { role: "assistant", content: text },
+      }],
+    });
+  });
+}
+
+export { chat };

src/api/models.ts

@@ -0,0 +1,28 @@
+import { Hono } from "jsr:@hono/hono";
+import { BlankEnv, BlankSchema } from "jsr:@hono/hono/types";
+
+function models(app: Hono<BlankEnv, BlankSchema, "/">) {
+  app.get("/v1/models", (c) => {
+    return c.json({
+      data: [{
+        "id": "gpt-4o-mini",
+        "object": "model",
+        "owned_by": "duckduckgo-chat-ai",
+      }, {
+        "id": "claude-3-haiku",
+        "object": "model",
+        "owned_by": "duckduckgo-chat-ai",
+      }, {
+        "id": "llama",
+        "object": "model",
+        "owned_by": "duckduckgo-chat-ai",
+      }, {
+        "id": "mixtral",
+        "object": "model",
+        "owned_by": "duckduckgo-chat-ai",
+      }],
+    });
+  });
+}
+
+export { models };

src/auth.ts

@@ -0,0 +1,12 @@
+import { Hono } from "jsr:@hono/hono";
+import { bearerAuth } from "jsr:@hono/hono/bearer-auth";
+import { BlankEnv, BlankSchema } from "jsr:@hono/hono/types";
+
+function auth(app: Hono<BlankEnv, BlankSchema, "/">) {
+  const token = Deno.env.get("TOKEN");
+  if (token) {
+    app.use("/v1/*", bearerAuth({ token }));
+  }
+}
+
+export { auth };

src/cache.ts

@@ -0,0 +1,47 @@
+import { Chat } from "jsr:@mumulhl/duckduckgo-ai-chat@3";
+
+type Messages = { content: string; role: "user" | "assistant" | "system" }[];
+
+const chatCache = new Map<string, Chat>();
+
+function setCache(chat: Chat) {
+  const messages_only_content = chat.messages.map((m) => m.content);
+  const stringify = JSON.stringify(messages_only_content);
+  chatCache.set(stringify, chat);
+}
+
+function setRedoCache(chat: Chat) {
+  const chatRedo = structuredClone(chat);
+  chatRedo.messages.pop();
+  chatRedo.messages.pop();
+  chatRedo.newVqd = chatRedo.oldVqd;
+  setCache(chatRedo);
+}
+
+function findCache(messages: Messages): Chat | undefined {
+  const messages_only_content = messages.map((m) => m.content);
+  const stringifyRedo = JSON.stringify(messages_only_content);
+  let chat = chatCache.get(stringifyRedo);
+  if (chat) {
+    // redo
+    return chat;
+  } else {
+    messages_only_content.pop();
+    const stringify = JSON.stringify(messages_only_content);
+    chat = chatCache.get(stringify);
+    removeCache(messages_only_content);
+
+    messages_only_content.pop();
+    messages_only_content.pop();
+    removeCache(messages_only_content);
+
+    return chat;
+  }
+}
+
+function removeCache(messages_only_content: string[]) {
+  const stringify = JSON.stringify(messages_only_content);
+  chatCache.delete(stringify);
+}
+
+export { chatCache, findCache, setCache, setRedoCache };

src/cron.ts

@@ -0,0 +1,14 @@
+import * as cache from "./cache.ts";
+
+function cron() {
+  const cron_var = Deno.env.get("CLEAN_CACHE_CRON");
+  let cron = 1;
+  if (cron_var !== undefined) {
+    cron = Number(cron_var);
+  }
+  Deno.cron("Clean cache", { hour: { every: cron } }, () => {
+    cache.chatCache.clear();
+  });
+}
+
+export { cron };

src/limit.ts

@@ -0,0 +1,22 @@
+import { Hono } from "jsr:@hono/hono";
+import { BlankEnv, BlankSchema } from "jsr:@hono/hono/types";
+
+import { rateLimiter } from "npm:hono-rate-limiter";
+
+function limit(app: Hono<BlankEnv, BlankSchema, "/">) {
+  const limit_var = Deno.env.get("LIMIT");
+  let limit = 2;
+  if (limit_var !== undefined) {
+    limit = Number(limit_var);
+  }
+  const limiter = rateLimiter({
+    windowMs: 1000,
+    limit,
+    standardHeaders: "draft-6",
+    keyGenerator: (_) => "1",
+  });
+
+  app.use("/v1/*", limiter);
+}
+
+export { limit };