@m6d/cortex-server 1.1.1 → 1.1.2

package/src/adapters/mssql.ts

@@ -1,203 +1,179 @@
 import type { ToolUIPart, UIMessage } from "ai";
-import {
-  and,
-  desc,
-  eq,
-  getColumns,
-  inArray,
-  type InferInsertModel,
-} from "drizzle-orm";
+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;
+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

@@ -1,6 +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>;
+    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

@@ -1,39 +1,39 @@
 import type { ResolvedCortexAgentConfig } from "../config.ts";
 
 export async function fetchBackend(
-  path: string,
-  backendFetch: NonNullable<ResolvedCortexAgentConfig["backendFetch"]>,
-  token: string,
-  options?: RequestInit,
+    path: string,
+    backendFetch: NonNullable<ResolvedCortexAgentConfig["backendFetch"]>,
+    token: string,
+    options?: RequestInit,
 ) {
-  let finalOptions = options;
+    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
+    // 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,
-    },
-  });
+    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

@@ -2,35 +2,31 @@ 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,
-  });
+    const provider = createOpenAICompatible({
+        name: config.providerName ?? "default",
+        baseURL: config.baseURL,
+        apiKey: config.apiKey,
+    });
 
-  return provider(config.modelName);
+    return provider(config.modelName);
 }
 
-export function createEmbeddingModel(
-  config: ResolvedCortexAgentConfig["embedding"],
-) {
-  const provider = createOpenAICompatible({
-    name: "embedding",
-    baseURL: config.baseURL,
-    apiKey: config.apiKey,
-  });
+export function createEmbeddingModel(config: ResolvedCortexAgentConfig["embedding"]) {
+    const provider = createOpenAICompatible({
+        name: "embedding",
+        baseURL: config.baseURL,
+        apiKey: config.apiKey,
+    });
 
-  return provider.textEmbeddingModel(config.modelName);
+    return provider.textEmbeddingModel(config.modelName);
 }
 
-export function streamToBase64(stream: ReadableStream<Uint8Array>) {
-  return new Response(stream)
-    .arrayBuffer()
-    .then((buffer) => Buffer.from(buffer).toString("base64"));
+export async 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;
+    return JSON.parse(Buffer.from(token.split(".")[1]!, "base64").toString())["sub"] as string;
 }