@m6d/cortex-server 1.1.1 → 1.2.0

package/README.md

@@ -8,50 +8,50 @@ Multi-agent AI chat server built on Hono + Bun. Supports MSSQL persistence, MinI
 import { createCortex } from "@m6d/cortex-server";
 
 const cortex = createCortex({
-  database: {
-    type: "mssql",
-    connectionString: process.env.DB_CONNECTION_STRING!,
-  },
-  storage: {
-    endPoint: "localhost",
-    port: 9000,
-    useSSL: false,
-    accessKey: "minioadmin",
-    secretKey: "minioadmin",
-  },
-  auth: {
-    jwksUri: "https://your-auth-provider/.well-known/jwks.json",
-    issuer: "https://your-auth-provider/",
-  },
-  model: {
-    baseURL: "https://api.openai.com/v1",
-    apiKey: process.env.MODEL_KEY!,
-    modelName: "gpt-4o",
-  },
-  embedding: {
-    baseURL: "https://api.openai.com/v1",
-    apiKey: process.env.EMBEDDING_KEY!,
-    modelName: "text-embedding-3-small",
-    dimension: 1536,
-  },
-  neo4j: {
-    url: "bolt://localhost:7687",
-    user: "neo4j",
-    password: "password",
-  },
-  agents: {
-    assistant: {
-      systemPrompt: "You are a helpful assistant.",
-      tools: {},
+    database: {
+        type: "mssql",
+        connectionString: process.env.DB_CONNECTION_STRING!,
+    },
+    storage: {
+        endPoint: "localhost",
+        port: 9000,
+        useSSL: false,
+        accessKey: "minioadmin",
+        secretKey: "minioadmin",
+    },
+    auth: {
+        jwksUri: "https://your-auth-provider/.well-known/jwks.json",
+        issuer: "https://your-auth-provider/",
+    },
+    model: {
+        baseURL: "https://api.openai.com/v1",
+        apiKey: process.env.MODEL_KEY!,
+        modelName: "gpt-4o",
+    },
+    embedding: {
+        baseURL: "https://api.openai.com/v1",
+        apiKey: process.env.EMBEDDING_KEY!,
+        modelName: "text-embedding-3-small",
+        dimension: 1536,
+    },
+    neo4j: {
+        url: "bolt://localhost:7687",
+        user: "neo4j",
+        password: "password",
+    },
+    agents: {
+        assistant: {
+            systemPrompt: "You are a helpful assistant.",
+            tools: {},
+        },
     },
-  },
 });
 
 const server = await cortex.serve();
 
 export default {
-  fetch: server.fetch,
-  websocket: server.websocket,
+    fetch: server.fetch,
+    websocket: server.websocket,
 };
 ```
 

package/dist/src/ai/interceptors/{resolve-captured-files.d.ts → request-interceptor.d.ts}

@@ -4,8 +4,9 @@ export type ResolvedFile = {
     name: string;
     bytes: string;
 };
-export declare function createCapturedFileInterceptor(db: DatabaseAdapter, storage: StorageAdapter, options?: {
+export type RequestInterceptorOptions = {
     transformFile?: (file: ResolvedFile) => unknown;
-}): (body: Record<string, unknown>, context: {
+};
+export declare function createRequestInterceptor(db: DatabaseAdapter, storage: StorageAdapter, options?: RequestInterceptorOptions): (body: Record<string, unknown>, context: {
     token: string;
 }) => Promise<Record<string, unknown>>;

package/dist/src/config.d.ts

@@ -1,7 +1,8 @@
-import type { UIMessage } from "ai";
+import type { ToolSet, UIMessage } from "ai";
 import type { DatabaseAdapter } from "./adapters/database";
 import type { StorageAdapter } from "./adapters/storage";
 import type { DomainDef } from "./graph/types.ts";
+import type { RequestInterceptorOptions } from "./ai/interceptors/request-interceptor.ts";
 export type KnowledgeConfig = {
     swagger?: {
         url: string;
@@ -22,7 +23,7 @@ export type StorageConfig = {
 };
 export type CortexAgentDefinition = {
     systemPrompt: string | ((session: Record<string, unknown> | null) => string | Promise<string>);
-    tools?: Record<string, unknown>;
+    tools?: ToolSet;
     backendFetch?: {
         baseUrl: string;
         apiKey: string;
@@ -30,6 +31,7 @@ export type CortexAgentDefinition = {
         transformRequestBody?: (body: Record<string, unknown>, context: {
             token: string;
         }) => Promise<Record<string, unknown>>;
+        interceptor?: RequestInterceptorOptions;
     };
     loadSessionData?: (token: string) => Promise<Record<string, unknown>>;
     onToolCall?: (toolCall: {
@@ -89,7 +91,7 @@ export type ResolvedCortexAgentConfig = {
         apiKey: string;
     };
     systemPrompt: string | ((session: Record<string, unknown> | null) => string | Promise<string>);
-    tools?: Record<string, unknown>;
+    tools?: ToolSet;
     backendFetch?: {
         baseUrl: string;
         apiKey: string;
@@ -97,6 +99,7 @@ export type ResolvedCortexAgentConfig = {
         transformRequestBody?: (body: Record<string, unknown>, context: {
             token: string;
         }) => Promise<Record<string, unknown>>;
+        interceptor?: RequestInterceptorOptions;
     };
     loadSessionData?: (token: string) => Promise<Record<string, unknown>>;
     onToolCall?: (toolCall: {

package/dist/src/factory.d.ts

@@ -15,4 +15,16 @@ export type CortexInstance = {
         write?: boolean;
     }): Promise<void>;
 };
-export declare function createCortex(config: CortexConfig): CortexInstance;
+export declare function createCortex(config: CortexConfig): {
+    serve(): Promise<{
+        app: Hono<AppEnv, import("hono/types").BlankSchema, "/">;
+        port: number;
+        fetch: (request: Request, Env?: {} | undefined, executionCtx?: import("hono").ExecutionContext) => Response | Promise<Response>;
+        websocket: import("hono/bun").BunWebSocketHandler<import("hono/bun").BunWebSocketData>;
+    }>;
+    seedGraph(): Promise<void>;
+    extractEndpoints(options: {
+        domainsDir: string;
+        write?: boolean;
+    }): Promise<void>;
+};

package/dist/src/index.d.ts

@@ -2,6 +2,8 @@ export type { CortexConfig, CortexAgentDefinition, KnowledgeConfig, DatabaseConf
 export type { Thread, AppEnv } from "./types";
 export type { CortexInstance } from "./factory";
 export { createCortex } from "./factory";
+export type { ResolvedFile, RequestInterceptorOptions, } from "./ai/interceptors/request-interceptor";
+export { createRequestInterceptor } from "./ai/interceptors/request-interceptor";
 export { captureFilesTool } from "./ai/tools/capture-files.tool";
 export { createQueryGraphTool } from "./ai/tools/query-graph.tool";
 export { createCallEndpointTool } from "./ai/tools/call-endpoint.tool";

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

@@ -1,3 +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/package.json

@@ -1,57 +1,57 @@
 {
-  "name": "@m6d/cortex-server",
-  "version": "1.1.1",
-  "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"
+    "name": "@m6d/cortex-server",
+    "version": "1.2.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"
     }
-  },
-  "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

@@ -2,32 +2,25 @@ 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>;
-  };
+    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

@@ -3,87 +3,87 @@ 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;
+    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");
-  }
+    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 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;
+    const bucketName = config.bucketName ?? "ai-storage";
+    let bucketReady = false;
 
-  async function ensureBucket() {
-    if (bucketReady) return;
-    if (!(await client.bucketExists(bucketName))) {
-      await client.makeBucket(bucketName);
+    async function ensureBucket() {
+        if (bucketReady) return;
+        if (!(await client.bucketExists(bucketName))) {
+            await client.makeBucket(bucketName);
+        }
+        bucketReady = true;
     }
-    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;
-      }
-    },
+    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[] = [];
+        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("error", () => {
+                        reject();
+                    });
 
-          stream.on("data", (chunk) => chunks.push(chunk));
-          stream.on("end", () => {
-            const buffer = Buffer.concat(chunks);
-            resolve(buffer.toString("base64"));
-          });
-        });
-      } catch {
-        return false;
-      }
-    },
+                    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 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;
-    },
-  };
+        async stream(path: string) {
+            const nodeStream = await client.getObject(bucketName, path);
+            return Readable.toWeb(nodeStream) as unknown as ReadableStream;
+        },
+    };
 
-  return adapter;
+    return adapter;
 }