@m6d/cortex-server 1.0.0

package/dist/src/routes/threads.d.ts

@@ -0,0 +1,3 @@
+import { Hono } from "hono";
+import type { CortexAppEnv } from "../types.ts";
+export declare function createThreadRoutes(): Hono<CortexAppEnv, import("hono/types").BlankSchema, "/">;

package/dist/src/routes/ws.d.ts

@@ -0,0 +1,3 @@
+import { Hono } from "hono";
+import type { AppEnv } from "../types.ts";
+export declare function createWsRoute(): Hono<AppEnv, import("hono/types").BlankSchema, "/">;

package/dist/src/types.d.ts

@@ -0,0 +1,56 @@
+import type { UIMessage } from "ai";
+import type { ResolvedCortexAgentConfig } from "./config";
+export type Thread = {
+    id: string;
+    userId: string;
+    agentId: string;
+    title: string | null;
+    session: Record<string, unknown> | null;
+    createdAt: Date;
+    updatedAt: Date;
+};
+export type StoredMessage = {
+    id: string;
+    threadId: string;
+    text: string | null;
+    content: UIMessage;
+    role: "system" | "user" | "assistant" | "tool";
+    createdAt: Date;
+    updatedAt: Date;
+};
+export type CapturedFileInput = {
+    id: string;
+    file: {
+        name: string;
+        bytes: string;
+    };
+};
+export type AppEnv = {
+    Bindings: {};
+    Variables: {
+        user: {
+            id: string;
+            token: string;
+        } | undefined;
+    };
+};
+export type AuthedAppEnv = {
+    Bindings: {};
+    Variables: {
+        user: {
+            id: string;
+            token: string;
+        };
+    };
+};
+export type CortexAppEnv = {
+    Bindings: {};
+    Variables: {
+        user: {
+            id: string;
+            token: string;
+        };
+        agentConfig: ResolvedCortexAgentConfig;
+        agentId: string;
+    };
+};

package/dist/src/ws/connections.d.ts

@@ -0,0 +1,4 @@
+import type { WSContext } from "hono/ws";
+export declare function addConnection(userId: string, ws: WSContext): void;
+export declare function removeConnection(userId: string, ws: WSContext): void;
+export declare function getConnections(userId: string): WSContext<unknown>[];

package/dist/src/ws/events.d.ts

@@ -0,0 +1,8 @@
+export type ThreadTitleUpdatedEvent = {
+    type: "thread:title-updated";
+    payload: {
+        threadId: string;
+        title: string;
+    };
+};
+export type WsEvent = ThreadTitleUpdatedEvent;

package/dist/src/ws/index.d.ts

@@ -0,0 +1,3 @@
+export { addConnection, removeConnection, getConnections, } from "./connections.ts";
+export { notify } from "./notify.ts";
+export type { WsEvent, ThreadTitleUpdatedEvent } from "./events.ts";

package/dist/src/ws/notify.d.ts

@@ -0,0 +1,2 @@
+import type { WsEvent } from "./events.ts";
+export declare function notify(userId: string, event: WsEvent): void;

package/index.ts

@@ -0,0 +1 @@
+export * from "./src/index";

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "@m6d/cortex-server",
+  "version": "1.0.0",
+  "description": "Reusable AI agent chat server library for Hono + Bun",
+  "license": "MIT",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "bun": "./index.ts",
+      "default": "./index.ts"
+    }
+  },
+  "main": "./index.ts",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "src",
+    "index.ts",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "db:generate": "drizzle-kit generate",
+    "db:migrate": "drizzle-kit migrate"
+  },
+  "dependencies": {
+    "@ai-sdk/provider": "^3.0.0",
+    "@hono/zod-validator": "^0.5.0",
+    "drizzle-orm": "^1.0.0-beta.15-859cf75",
+    "minio": "^8.0.7",
+    "mssql": "^12.2.0"
+  },
+  "devDependencies": {
+    "@ai-sdk/openai-compatible": "^2.0.0",
+    "@types/bun": "latest",
+    "@types/minio": "^7.1.1",
+    "@types/mssql": "^9.1.5",
+    "ai": "^6.0.104",
+    "drizzle-kit": "^1.0.0-beta.15-859cf75",
+    "hono": "^4.12.3",
+    "typescript": "^5"
+  },
+  "peerDependencies": {
+    "@ai-sdk/openai-compatible": "^2.0.0",
+    "ai": "^6.0.0",
+    "hono": "^4.12.3",
+    "jose": "^6.1.3",
+    "zod": "^3.24.0"
+  },
+  "engines": {
+    "bun": ">=1.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/src/adapters/database.ts

@@ -0,0 +1,33 @@
+import type { ToolUIPart, UIMessage } from "ai";
+import type { Thread, StoredMessage, CapturedFileInput } from "../types";
+
+export type DatabaseAdapter = {
+  threads: {
+    list(userId: string, agentId: string): Promise<Thread[]>;
+    getById(userId: string, threadId: string): Promise<Thread | null>;
+    create(userId: string, agentId: string): Promise<Thread>;
+    delete(userId: string, threadId: string): Promise<void>;
+    updateTitle(threadId: string, title: string): Promise<void>;
+    updateSession(
+      threadId: string,
+      session: Record<string, unknown>,
+    ): Promise<void>;
+  };
+  messages: {
+    list(
+      userId: string,
+      threadId: string,
+      opts?: { limit?: number },
+    ): Promise<StoredMessage[]>;
+    upsert(threadId: string, messages: UIMessage[]): Promise<void>;
+  };
+  capturedFiles: {
+    create(
+      userId: string,
+      messageId: string,
+      toolPart: ToolUIPart,
+      files: CapturedFileInput[],
+    ): Promise<{ id: string; uploadId: string }[]>;
+    getById(id: string, userId: string): Promise<{ name: string } | null>;
+  };
+};

package/src/adapters/minio.ts

@@ -0,0 +1,89 @@
+import * as Minio from "minio";
+import { Readable } from "node:stream";
+import type { StorageAdapter } from "./storage";
+
+export type MinioConfig = {
+  endPoint: string;
+  port: number;
+  useSSL: boolean;
+  accessKey: string;
+  secretKey: string;
+  bucketName?: string;
+};
+
+export function createMinioAdapter(config: MinioConfig) {
+  if (!config.endPoint) {
+    throw new Error("MinIO adapter: endPoint is required");
+  }
+
+  const client = new Minio.Client({
+    endPoint: config.endPoint,
+    port: config.port,
+    useSSL: config.useSSL,
+    accessKey: config.accessKey,
+    secretKey: config.secretKey,
+  });
+
+  const bucketName = config.bucketName ?? "ai-storage";
+  let bucketReady = false;
+
+  async function ensureBucket() {
+    if (bucketReady) return;
+    if (!(await client.bucketExists(bucketName))) {
+      await client.makeBucket(bucketName);
+    }
+    bucketReady = true;
+  }
+
+  const adapter: StorageAdapter = {
+    async put(path: string, data: string) {
+      try {
+        await ensureBucket();
+        await client.putObject(bucketName, path, Buffer.from(data, "base64"));
+        return true;
+      } catch {
+        return false;
+      }
+    },
+
+    async get(path: string) {
+      try {
+        const stream = await client.getObject(bucketName, path);
+        return await new Promise<string>((resolve, reject) => {
+          const chunks: Uint8Array[] = [];
+
+          stream.on("error", () => {
+            reject();
+          });
+
+          stream.on("data", (chunk) => chunks.push(chunk));
+          stream.on("end", () => {
+            const buffer = Buffer.concat(chunks);
+            resolve(buffer.toString("base64"));
+          });
+        });
+      } catch {
+        return false;
+      }
+    },
+
+    async delete(paths: string[]) {
+      try {
+        await client.removeObjects(
+          bucketName,
+          paths.map((x) => ({ name: x })),
+        );
+        return true;
+      } catch {
+        return false;
+      }
+    },
+
+    async stream(path: string) {
+      const nodeStream = await client.getObject(bucketName, path);
+      return Readable.toWeb(nodeStream) as unknown as ReadableStream;
+    },
+  };
+
+  return adapter;
+}

package/src/adapters/mssql.ts

@@ -0,0 +1,203 @@
+import type { ToolUIPart, UIMessage } from "ai";
+import {
+  and,
+  desc,
+  eq,
+  getColumns,
+  inArray,
+  type InferInsertModel,
+} from "drizzle-orm";
+import { drizzle } from "drizzle-orm/node-mssql";
+import { threads, messages, capturedFiles } from "../db/schema";
+import type { DatabaseAdapter } from "./database";
+import type { StorageAdapter } from "./storage";
+import type { Thread, CapturedFileInput } from "../types";
+
+export function createMssqlAdapter(
+  connectionString: string,
+  storage: StorageAdapter,
+) {
+  const db = drizzle(connectionString, { casing: "snake_case" });
+
+  const adapter: DatabaseAdapter = {
+    threads: {
+      async list(userId: string, agentId: string) {
+        return (await db
+          .select()
+          .from(threads)
+          .where(and(eq(threads.userId, userId), eq(threads.agentId, agentId)))
+          .orderBy(desc(threads.createdAt))) as Thread[];
+      },
+
+      async getById(userId: string, threadId: string) {
+        const result = await db
+          .select()
+          .top(1)
+          .from(threads)
+          .where(and(eq(threads.id, threadId), eq(threads.userId, userId)))
+          .execute();
+        return result.length ? (result[0] as Thread) : null;
+      },
+
+      async create(userId: string, agentId: string) {
+        const result = await db
+          .insert(threads)
+          .output()
+          .values({ userId, agentId })
+          .execute();
+        return result[0] as Thread;
+      },
+
+      async delete(userId: string, threadId: string) {
+        const capturedFilePaths = await db
+          .select({ id: capturedFiles.id })
+          .from(capturedFiles)
+          .innerJoin(messages, eq(messages.id, capturedFiles.messageId))
+          .innerJoin(threads, eq(threads.id, messages.threadId))
+          .where(and(eq(threads.id, threadId), eq(threads.userId, userId)))
+          .execute()
+          .then((x) => x.map((y) => `captured_files/${y.id}`));
+
+        await storage.delete(capturedFilePaths);
+
+        await db
+          .delete(threads)
+          .where(and(eq(threads.id, threadId), eq(threads.userId, userId)))
+          .execute();
+      },
+
+      async updateTitle(threadId: string, title: string) {
+        await db
+          .update(threads)
+          .set({ title })
+          .where(eq(threads.id, threadId))
+          .execute();
+      },
+
+      async updateSession(threadId: string, session: Record<string, unknown>) {
+        await db
+          .update(threads)
+          .set({ session })
+          .where(eq(threads.id, threadId))
+          .execute();
+      },
+    },
+
+    messages: {
+      async list(userId: string, threadId: string, opts?: { limit?: number }) {
+        return await db
+          .select(getColumns(messages))
+          .from(messages)
+          .innerJoin(threads, eq(threads.id, messages.threadId))
+          .where(and(eq(threads.userId, userId), eq(threads.id, threadId)))
+          .orderBy(desc(messages.createdAt))
+          .offset(0)
+          .fetch(opts?.limit ?? 100)
+          .then((x) => x.reverse());
+      },
+
+      async upsert(threadId: string, messagesToInsert: UIMessage[]) {
+        const ids = messagesToInsert.map((x) => x.id);
+
+        const existingIds = await db
+          .select({ id: messages.id })
+          .from(messages)
+          .where(inArray(messages.id, ids))
+          .execute()
+          .then((x) => x.map((y) => y.id));
+
+        const newMessages = messagesToInsert.filter(
+          (x) => !existingIds.includes(x.id),
+        );
+
+        if (newMessages.length) {
+          await db
+            .insert(messages)
+            .values(
+              newMessages.map(
+                (x) =>
+                  ({
+                    id: x.id,
+                    role: x.role,
+                    threadId,
+                    content: x,
+                    text: x.parts.find((y) => y.type === "text")?.text,
+                  }) satisfies InferInsertModel<typeof messages>,
+              ),
+            )
+            .execute();
+        }
+
+        const existingMessages = messagesToInsert.filter((x) =>
+          existingIds.includes(x.id),
+        );
+        if (existingMessages.length) {
+          await db.transaction(async (tx) => {
+            for (const message of existingMessages) {
+              await tx
+                .update(messages)
+                .set({
+                  content: message,
+                  text: message.parts.find((x) => x.type === "text")?.text,
+                })
+                .where(eq(messages.id, message.id))
+                .execute();
+            }
+          });
+        }
+      },
+    },
+
+    capturedFiles: {
+      async create(
+        userId: string,
+        messageId: string,
+        toolPart: ToolUIPart,
+        files: CapturedFileInput[],
+      ) {
+        const result = await db
+          .insert(capturedFiles)
+          .output({ id: capturedFiles.id })
+          .values(
+            files.map(
+              (file) =>
+                ({
+                  userId,
+                  messageId,
+                  toolPart,
+                  name: file.file.name,
+                  agentGeneratedId: file.id,
+                }) satisfies InferInsertModel<typeof capturedFiles>,
+            ),
+          )
+          .execute()
+          .then((x) => x.map((y) => y.id));
+
+        await Promise.all(
+          result.map(
+            async (id, idx) =>
+              await storage.put(`captured_files/${id}`, files[idx]!.file.bytes),
+          ),
+        );
+
+        return result.map((r, i) => ({ id: files[i]!.id, uploadId: r }));
+      },
+
+      async getById(id: string, userId: string) {
+        const file = await db
+          .select()
+          .top(1)
+          .from(capturedFiles)
+          .where(
+            and(eq(capturedFiles.id, id), eq(capturedFiles.userId, userId)),
+          )
+          .execute()
+          .then((x) => (x.length ? x[0] : null));
+
+        return file ? { name: file.name } : null;
+      },
+    },
+  };
+
+  return adapter;
+}

package/src/adapters/storage.ts

@@ -0,0 +1,6 @@
+export type StorageAdapter = {
+  put(path: string, data: string): Promise<boolean>;
+  get(path: string): Promise<string | false>;
+  delete(paths: string[]): Promise<boolean>;
+  stream(path: string): Promise<ReadableStream>;
+};

package/src/ai/fetch.ts

@@ -0,0 +1,39 @@
+import type { ResolvedCortexAgentConfig } from "../config.ts";
+
+export async function fetchBackend(
+  path: string,
+  backendFetch: NonNullable<ResolvedCortexAgentConfig["backendFetch"]>,
+  token: string,
+  options?: RequestInit,
+) {
+  let finalOptions = options;
+
+  // Apply body interceptor if configured and request has a body
+  if (
+    backendFetch.transformRequestBody &&
+    finalOptions?.body &&
+    typeof finalOptions.body === "string"
+  ) {
+    try {
+      const parsed = JSON.parse(finalOptions.body) as Record<string, unknown>;
+      const transformed = await backendFetch.transformRequestBody(parsed, {
+        token,
+      });
+      finalOptions = { ...finalOptions, body: JSON.stringify(transformed) };
+    } catch {
+      // If body isn't valid JSON, pass through as-is
+    }
+  }
+
+  return fetch(`${backendFetch.baseUrl}${path}`, {
+    ...finalOptions,
+    headers: {
+      "Content-Type": "application/json",
+      "X-Requested-With": "cortex-server",
+      "X-Service-Api-Key": backendFetch.apiKey,
+      "X-Service-Token": token,
+      ...backendFetch.headers,
+      ...finalOptions?.headers,
+    },
+  });
+}

package/src/ai/helpers.ts

@@ -0,0 +1,36 @@
+import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
+import type { ResolvedCortexAgentConfig } from "../config.ts";
+
+export function createModel(config: ResolvedCortexAgentConfig["model"]) {
+  const provider = createOpenAICompatible({
+    name: config.providerName ?? "default",
+    baseURL: config.baseURL,
+    apiKey: config.apiKey,
+  });
+
+  return provider(config.modelName);
+}
+
+export function createEmbeddingModel(
+  config: ResolvedCortexAgentConfig["embedding"],
+) {
+  const provider = createOpenAICompatible({
+    name: "embedding",
+    baseURL: config.baseURL,
+    apiKey: config.apiKey,
+  });
+
+  return provider.textEmbeddingModel(config.modelName);
+}
+
+export function streamToBase64(stream: ReadableStream<Uint8Array>) {
+  return new Response(stream)
+    .arrayBuffer()
+    .then((buffer) => Buffer.from(buffer).toString("base64"));
+}
+
+export function tokenToUserId(token: string) {
+  return JSON.parse(Buffer.from(token.split(".")[1]!, "base64").toString())[
+    "sub"
+  ] as string;
+}