@m6d/cortex-server 1.1.1 → 1.2.0

package/src/routes/chat.ts

@@ -7,32 +7,32 @@ import { requireAuth } from "../auth/middleware.ts";
 import { stream } from "../ai/index.ts";
 
 export function createChatRoutes() {
-  const app = new Hono<CortexAppEnv>();
+    const app = new Hono<CortexAppEnv>();
 
-  app.post(
-    "/chat",
-    requireAuth,
-    zValidator(
-      "json",
-      z.object({
-        id: z.string(),
-        messages: z.array(z.unknown()),
-      }),
-    ),
-    async function (c) {
-      const config = c.get("agentConfig");
-      const { id: userId, token } = c.get("user");
-      const { messages, id: threadId } = c.req.valid("json");
+    app.post(
+        "/chat",
+        requireAuth,
+        zValidator(
+            "json",
+            z.object({
+                id: z.string(),
+                messages: z.array(z.unknown()),
+            }),
+        ),
+        async function (c) {
+            const config = c.get("agentConfig");
+            const { id: userId, token } = c.get("user");
+            const { messages, id: threadId } = c.req.valid("json");
 
-      const thread = await config.db.threads.getById(userId, threadId);
+            const thread = await config.db.threads.getById(userId, threadId);
 
-      if (!thread) {
-        throw new HTTPException(404, { message: "Not found" });
-      }
+            if (!thread) {
+                throw new HTTPException(404, { message: "Not found" });
+            }
 
-      return stream(messages, thread, userId, token, config);
-    },
-  );
+            return stream(messages, thread, userId, token, config);
+        },
+    );
 
-  return app;
+    return app;
 }

package/src/routes/files.ts

@@ -7,99 +7,94 @@ import type { CortexAppEnv } from "../types.ts";
 import { requireAuth } from "../auth/middleware.ts";
 
 export function createFileRoutes() {
-  const app = new Hono<CortexAppEnv>();
+    const app = new Hono<CortexAppEnv>();
 
-  app.get("/files/:id", requireAuth, async function (c) {
-    const config = c.get("agentConfig");
-    const id = c.req.param("id");
-    const { id: userId } = c.get("user");
-    const file = await config.db.capturedFiles.getById(id, userId);
+    app.get("/files/:id", requireAuth, async function (c) {
+        const config = c.get("agentConfig");
+        const id = c.req.param("id");
+        const { id: userId } = c.get("user");
+        const file = await config.db.capturedFiles.getById(id, userId);
 
-    if (!file) {
-      throw new HTTPException(404, { message: "File not found" });
-    }
+        if (!file) {
+            throw new HTTPException(404, { message: "File not found" });
+        }
 
-    const fileStream = await config.storage.stream(`captured_files/${id}`);
-    return new Response(fileStream, {
-      headers: {
-        "Content-Type": "application/octet-stream",
-        "Content-Disposition": `attachment; filename="${file.name}"`,
-      },
+        const fileStream = await config.storage.stream(`captured_files/${id}`);
+        return new Response(fileStream, {
+            headers: {
+                "Content-Type": "application/octet-stream",
+                "Content-Disposition": `attachment; filename="${file.name}"`,
+            },
+        });
     });
-  });
 
-  app.post(
-    "/files",
-    requireAuth,
-    zValidator(
-      "json",
-      z.object({
-        toolCallId: z.string(),
-        message: z.unknown().transform(async (message, ctx) => {
-          const result = await safeValidateUIMessages({
-            messages: [message],
-          });
-          if (!result.success) {
-            ctx.addIssue({
-              code: "custom",
-              path: ["message"],
-              message: "Invalid message format",
-            });
-            return z.NEVER;
-          }
+    app.post(
+        "/files",
+        requireAuth,
+        zValidator(
+            "json",
+            z.object({
+                toolCallId: z.string(),
+                message: z.unknown().transform(async (message, ctx) => {
+                    const result = await safeValidateUIMessages({
+                        messages: [message],
+                    });
+                    if (!result.success) {
+                        ctx.addIssue({
+                            code: "custom",
+                            path: ["message"],
+                            message: "Invalid message format",
+                        });
+                        return z.NEVER;
+                    }
 
-          return result.data[0]!;
-        }),
-        files: z.array(
-          z.object({
-            id: z.string(),
-            file: z.object({
-              name: z.string(),
-              bytes: z.string(),
+                    return result.data[0]!;
+                }),
+                files: z.array(
+                    z.object({
+                        id: z.string(),
+                        file: z.object({
+                            name: z.string(),
+                            bytes: z.string(),
+                        }),
+                    }),
+                ),
             }),
-          }),
         ),
-      }),
-    ),
-    async function (c) {
-      const config = c.get("agentConfig");
-      const { message, toolCallId, files } = c.req.valid("json");
-      const { id: userId } = c.get("user");
+        async function (c) {
+            const config = c.get("agentConfig");
+            const { message, toolCallId, files } = c.req.valid("json");
+            const { id: userId } = c.get("user");
 
-      function isTool(value: UIMessage["parts"][number]): value is ToolUIPart {
-        return value.type.startsWith("tool-");
-      }
+            function isTool(value: UIMessage["parts"][number]): value is ToolUIPart {
+                return value.type.startsWith("tool-");
+            }
 
-      const toolPart = message.parts
-        .filter(isTool)
-        .find((x) => x.toolCallId === toolCallId);
+            const toolPart = message.parts.filter(isTool).find((x) => x.toolCallId === toolCallId);
 
-      if (!toolPart) {
-        throw new HTTPException(423, {
-          message: "Invalid tool call id",
-        });
-      }
+            if (!toolPart) {
+                throw new HTTPException(423, {
+                    message: "Invalid tool call id",
+                });
+            }
 
-      const result = await config.db.capturedFiles.create(
-        userId,
-        message.id,
-        toolPart,
-        files,
-      );
+            const result = await config.db.capturedFiles.create(
+                userId,
+                message.id,
+                toolPart,
+                files,
+            );
 
-      // Store file bytes
-      await Promise.all(
-        result.map(async (r, i) => {
-          await config.storage.put(
-            `captured_files/${r.uploadId}`,
-            files[i]!.file.bytes,
-          );
-        }),
-      );
+            // Store file bytes
+            await Promise.all(
+                result.map(async (r, i) => {
+                    await config.storage.put(`captured_files/${r.uploadId}`, files[i]!.file.bytes);
+                }),
+            );
 
-      return c.json(result);
-    },
-  );
+            return c.json(result);
+        },
+    );
 
-  return app;
+    return app;
 }

package/src/routes/threads.ts

@@ -6,64 +6,62 @@ import { requireAuth } from "../auth/middleware.ts";
 import { generateTitle } from "../ai/index.ts";
 
 export function createThreadRoutes() {
-  const app = new Hono<CortexAppEnv>();
+    const app = new Hono<CortexAppEnv>();
 
-  app.get("/threads", requireAuth, async function (c) {
-    const config = c.get("agentConfig");
-    const agentId = c.get("agentId");
-    const threads = await config.db.threads
-      .list(c.get("user").id, agentId)
-      .then((x) =>
-        x.map((y) => ({ id: y.id, title: y.title, createdAt: y.createdAt })),
-      );
-    return c.json(threads);
-  });
+    app.get("/threads", requireAuth, async function (c) {
+        const config = c.get("agentConfig");
+        const agentId = c.get("agentId");
+        const threads = await config.db.threads
+            .list(c.get("user").id, agentId)
+            .then((x) => x.map((y) => ({ id: y.id, title: y.title, createdAt: y.createdAt })));
+        return c.json(threads);
+    });
 
-  app.post(
-    "/threads",
-    requireAuth,
-    zValidator("json", z.object({ prompt: z.string() })),
-    async function (c) {
-      const config = c.get("agentConfig");
-      const agentId = c.get("agentId");
-      const { prompt } = c.req.valid("json");
-      const { id, createdAt, title } = await config.db.threads.create(
-        c.get("user").id,
-        agentId,
-      );
-      generateTitle(id, prompt, c.get("user").id, config);
-      return c.json({ id, title, createdAt });
-    },
-  );
+    app.post(
+        "/threads",
+        requireAuth,
+        zValidator("json", z.object({ prompt: z.string() })),
+        async function (c) {
+            const config = c.get("agentConfig");
+            const agentId = c.get("agentId");
+            const { prompt } = c.req.valid("json");
+            const { id, createdAt, title } = await config.db.threads.create(
+                c.get("user").id,
+                agentId,
+            );
+            generateTitle(id, prompt, c.get("user").id, config);
+            return c.json({ id, title, createdAt });
+        },
+    );
 
-  app.delete("/threads/:threadId", requireAuth, async function (c) {
-    const config = c.get("agentConfig");
-    const threadId = c.req.param("threadId");
-    await config.db.threads.delete(c.get("user").id, threadId);
-    return c.body(null, 204);
-  });
+    app.delete("/threads/:threadId", requireAuth, async function (c) {
+        const config = c.get("agentConfig");
+        const threadId = c.req.param("threadId");
+        await config.db.threads.delete(c.get("user").id, threadId);
+        return c.body(null, 204);
+    });
 
-  app.get("/threads/:threadId/messages", requireAuth, async function (c) {
-    const config = c.get("agentConfig");
-    const threadId = c.req.param("threadId");
-    const messages = await config.db.messages
-      .list(c.get("user").id, threadId)
-      .then((x) => x.map((y) => y.content));
-    return c.json(messages);
-  });
+    app.get("/threads/:threadId/messages", requireAuth, async function (c) {
+        const config = c.get("agentConfig");
+        const threadId = c.req.param("threadId");
+        const messages = await config.db.messages
+            .list(c.get("user").id, threadId)
+            .then((x) => x.map((y) => y.content));
+        return c.json(messages);
+    });
 
-  app.post(
-    "/threads/:threadId/session",
-    requireAuth,
-    zValidator("json", z.object({ session: z.record(z.unknown()) })),
-    async function (c) {
-      const config = c.get("agentConfig");
-      const threadId = c.req.param("threadId");
-      const { session } = c.req.valid("json");
-      await config.db.threads.updateSession(threadId, session);
-      return c.body(null, 204);
-    },
-  );
+    app.post(
+        "/threads/:threadId/session",
+        requireAuth,
+        zValidator("json", z.object({ session: z.record(z.unknown()) })),
+        async function (c) {
+            const config = c.get("agentConfig");
+            const threadId = c.req.param("threadId");
+            const { session } = c.req.valid("json");
+            await config.db.threads.updateSession(threadId, session);
+            return c.body(null, 204);
+        },
+    );
 
-  return app;
+    return app;
 }

package/src/routes/ws.ts

@@ -4,30 +4,30 @@ import type { AppEnv } from "../types.ts";
 import { addConnection, removeConnection } from "../ws/index.ts";
 
 export function createWsRoute() {
-  const app = new Hono<AppEnv>();
+    const app = new Hono<AppEnv>();
 
-  app.get(
-    "/ws",
-    upgradeWebSocket(function (c) {
-      const user = c.get("user");
-      const userId = user?.id;
+    app.get(
+        "/ws",
+        upgradeWebSocket(function (c) {
+            const user = c.get("user");
+            const userId = user?.id;
 
-      return {
-        onOpen(_, ws) {
-          if (userId) {
-            addConnection(userId, ws);
-          }
-          ws.send("Connected!");
-        },
+            return {
+                onOpen(_, ws) {
+                    if (userId) {
+                        addConnection(userId, ws);
+                    }
+                    ws.send("Connected!");
+                },
 
-        onClose(_, ws) {
-          if (userId) {
-            removeConnection(userId, ws);
-          }
-        },
-      };
-    }),
-  );
+                onClose(_, ws) {
+                    if (userId) {
+                        removeConnection(userId, ws);
+                    }
+                },
+            };
+        }),
+    );
 
-  return app;
+    return app;
 }

package/src/types.ts

@@ -2,49 +2,49 @@ import type { ToolUIPart, 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;
+    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;
+    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 };
+    id: string;
+    file: { name: string; bytes: string };
 };
 
 export type AppEnv = {
-  Bindings: {};
-  Variables: {
-    user: { id: string; token: string } | undefined;
-  };
+    Bindings: {};
+    Variables: {
+        user: { id: string; token: string } | undefined;
+    };
 };
 
 export type AuthedAppEnv = {
-  Bindings: {};
-  Variables: {
-    user: { id: string; token: string };
-  };
+    Bindings: {};
+    Variables: {
+        user: { id: string; token: string };
+    };
 };
 
 export type CortexAppEnv = {
-  Bindings: {};
-  Variables: {
-    user: { id: string; token: string };
-    agentConfig: ResolvedCortexAgentConfig;
-    agentId: string;
-  };
+    Bindings: {};
+    Variables: {
+        user: { id: string; token: string };
+        agentConfig: ResolvedCortexAgentConfig;
+        agentId: string;
+    };
 };

package/src/ws/connections.ts

@@ -3,21 +3,21 @@ import type { WSContext } from "hono/ws";
 const connections = new Map<string, WSContext[]>();
 
 export function addConnection(userId: string, ws: WSContext) {
-  const sockets = connections.get(userId) ?? [];
-  sockets.push(ws);
-  connections.set(userId, sockets);
+    const sockets = connections.get(userId) ?? [];
+    sockets.push(ws);
+    connections.set(userId, sockets);
 }
 
 export function removeConnection(userId: string, ws: WSContext) {
-  let sockets = connections.get(userId) ?? [];
-  sockets = sockets.filter((x) => x !== ws);
-  if (sockets.length) {
-    connections.set(userId, sockets);
-  } else {
-    connections.delete(userId);
-  }
+    let sockets = connections.get(userId) ?? [];
+    sockets = sockets.filter((x) => x !== ws);
+    if (sockets.length) {
+        connections.set(userId, sockets);
+    } else {
+        connections.delete(userId);
+    }
 }
 
 export function getConnections(userId: string) {
-  return connections.get(userId) ?? [];
+    return connections.get(userId) ?? [];
 }

package/src/ws/events.ts

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

package/src/ws/index.ts

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

package/src/ws/notify.ts

@@ -2,8 +2,8 @@ import { getConnections } from "./connections.ts";
 import type { WsEvent } from "./events.ts";
 
 export function notify(userId: string, event: WsEvent) {
-  const message = JSON.stringify(event);
-  for (const ws of getConnections(userId)) {
-    ws.send(message);
-  }
+    const message = JSON.stringify(event);
+    for (const ws of getConnections(userId)) {
+        ws.send(message);
+    }
 }

package/src/ai/interceptors/resolve-captured-files.ts

@@ -1,64 +0,0 @@
-import type { DatabaseAdapter } from "../../adapters/database.ts";
-import type { StorageAdapter } from "../../adapters/storage.ts";
-import { streamToBase64, tokenToUserId } from "../helpers.ts";
-
-export type ResolvedFile = {
-  name: string;
-  bytes: string;
-};
-
-export function createCapturedFileInterceptor(
-  db: DatabaseAdapter,
-  storage: StorageAdapter,
-  options?: { transformFile?: (file: ResolvedFile) => unknown },
-) {
-  const transformFile =
-    options?.transformFile ?? ((file: ResolvedFile) => file);
-
-  return async function resolveCapturedFiles(
-    body: Record<string, unknown>,
-    context: { token: string },
-  ) {
-    const userId = tokenToUserId(context.token);
-
-    async function traverse(obj: Record<string, unknown>) {
-      await Promise.all(
-        Object.keys(obj).map(async (key) => {
-          const value = obj[key];
-          if (typeof value === "string" && value.startsWith("capturedFile")) {
-            const [_, uploadId] = value.split("#");
-            const file = await db.capturedFiles.getById(uploadId!, userId);
-            if (file) {
-              const fileStream = await storage.stream(
-                `captured_files/${uploadId}`,
-              );
-              const bytes = await streamToBase64(fileStream);
-              obj[key] = transformFile({ name: file.name, bytes });
-            }
-          }
-
-          if (Array.isArray(value)) {
-            await Promise.all(
-              value.map(async (child) => {
-                if (typeof child === "object" && child !== null) {
-                  await traverse(child as Record<string, unknown>);
-                }
-              }),
-            );
-          }
-
-          if (
-            typeof value === "object" &&
-            value !== null &&
-            !Array.isArray(value)
-          ) {
-            await traverse(value as Record<string, unknown>);
-          }
-        }),
-      );
-    }
-
-    await traverse(body);
-    return body;
-  };
-}