@m6d/cortex-server 1.0.0

package/README.md

@@ -0,0 +1,64 @@
+# @m6d/cortex-server
+
+Multi-agent AI chat server built on Hono + Bun. Supports MSSQL persistence, MinIO file storage, Neo4j knowledge graphs, and AI streaming with tool execution.
+
+## Usage
+
+```ts
+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: {},
+    },
+  },
+});
+
+const server = await cortex.serve();
+
+export default {
+  fetch: server.fetch,
+  websocket: server.websocket,
+};
+```
+
+`cortex.serve()` is async — it runs database migrations on startup.
+
+Each key in `agents` becomes a route prefix (e.g. `assistant` → `/agents/assistant/...`). Agents can define per-agent `systemPrompt`, `tools`, `backendFetch`, `loadSessionData`, and lifecycle hooks (`onToolCall`, `onStreamFinish`).
+
+## Requirements
+
+- Bun >= 1.0.0

package/dist/index.d.ts

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

package/dist/src/adapters/database.d.ts

@@ -0,0 +1,27 @@
+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/dist/src/adapters/minio.d.ts

@@ -0,0 +1,10 @@
+import type { StorageAdapter } from "./storage";
+export type MinioConfig = {
+    endPoint: string;
+    port: number;
+    useSSL: boolean;
+    accessKey: string;
+    secretKey: string;
+    bucketName?: string;
+};
+export declare function createMinioAdapter(config: MinioConfig): StorageAdapter;

package/dist/src/adapters/mssql.d.ts

@@ -0,0 +1,3 @@
+import type { DatabaseAdapter } from "./database";
+import type { StorageAdapter } from "./storage";
+export declare function createMssqlAdapter(connectionString: string, storage: StorageAdapter): DatabaseAdapter;

package/dist/src/adapters/storage.d.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/dist/src/ai/fetch.d.ts

@@ -0,0 +1,2 @@
+import type { ResolvedCortexAgentConfig } from "../config.ts";
+export declare function fetchBackend(path: string, backendFetch: NonNullable<ResolvedCortexAgentConfig["backendFetch"]>, token: string, options?: RequestInit): Promise<Response>;

package/dist/src/ai/helpers.d.ts

@@ -0,0 +1,5 @@
+import type { ResolvedCortexAgentConfig } from "../config.ts";
+export declare function createModel(config: ResolvedCortexAgentConfig["model"]): import("@ai-sdk/provider").LanguageModelV3;
+export declare function createEmbeddingModel(config: ResolvedCortexAgentConfig["embedding"]): import("@ai-sdk/provider").EmbeddingModelV3;
+export declare function streamToBase64(stream: ReadableStream<Uint8Array>): Promise<string>;
+export declare function tokenToUserId(token: string): string;

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

@@ -0,0 +1,4 @@
+import type { ResolvedCortexAgentConfig } from "../config.ts";
+import type { Thread } from "../types.ts";
+export declare function stream(messages: unknown[], thread: Thread, userId: string, token: string, config: ResolvedCortexAgentConfig): Promise<Response>;
+export declare function generateTitle(threadId: string, prompt: string, userId: string, config: ResolvedCortexAgentConfig): Promise<void>;

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

@@ -0,0 +1,11 @@
+import type { DatabaseAdapter } from "../../adapters/database.ts";
+import type { StorageAdapter } from "../../adapters/storage.ts";
+export type ResolvedFile = {
+    name: string;
+    bytes: string;
+};
+export declare function createCapturedFileInterceptor(db: DatabaseAdapter, storage: StorageAdapter, options?: {
+    transformFile?: (file: ResolvedFile) => unknown;
+}): (body: Record<string, unknown>, context: {
+    token: string;
+}) => Promise<Record<string, unknown>>;

package/dist/src/ai/prompt.d.ts

@@ -0,0 +1,4 @@
+import type { ResolvedContext } from "../graph/resolver.ts";
+import type { ResolvedCortexAgentConfig } from "../config.ts";
+import type { Thread } from "../types.ts";
+export declare function buildSystemPrompt(config: ResolvedCortexAgentConfig, prompt: string, thread: Thread, token: string, resolved: ResolvedContext | null): Promise<string>;

package/dist/src/ai/tools/call-endpoint.tool.d.ts

@@ -0,0 +1,7 @@
+import type { ResolvedCortexAgentConfig } from "../../config.ts";
+export declare function createCallEndpointTool(backendFetch: NonNullable<ResolvedCortexAgentConfig["backendFetch"]>, token: string): import("ai").Tool<{
+    method: "GET" | "POST" | "PUT" | "DELETE";
+    path: string;
+    body?: string | undefined;
+    queryParams?: string | undefined;
+}, string>;

package/dist/src/ai/tools/capture-files.tool.d.ts

@@ -0,0 +1,6 @@
+export declare const captureFilesTool: import("ai").Tool<{
+    files: {
+        id: string;
+        label: string;
+    }[];
+}, never>;

package/dist/src/ai/tools/execute-code.tool.d.ts

@@ -0,0 +1,4 @@
+import type { ResolvedCortexAgentConfig } from "../../config.ts";
+export declare function createExecuteCodeTool(backendFetch: NonNullable<ResolvedCortexAgentConfig["backendFetch"]>, token: string): import("ai").Tool<{
+    code: string;
+}, string>;

package/dist/src/ai/tools/query-graph.tool.d.ts

@@ -0,0 +1,5 @@
+import type { Neo4jClient } from "../../graph/neo4j.ts";
+export declare function createQueryGraphTool(neo4j: Neo4jClient): import("ai").Tool<{
+    query: string;
+    parameters?: string | undefined;
+}, string>;

package/dist/src/auth/middleware.d.ts

@@ -0,0 +1,4 @@
+import type { AppEnv, AuthedAppEnv } from "../types";
+import type { CortexConfig } from "../config";
+export declare function createUserLoaderMiddleware(authConfig: CortexConfig["auth"]): import("hono").MiddlewareHandler<AppEnv, string, {}, Response>;
+export declare const requireAuth: import("hono").MiddlewareHandler<AuthedAppEnv, string, {}, Response>;

package/dist/src/cli/extract-endpoints.d.ts

@@ -0,0 +1,6 @@
+export type ExtractEndpointsOptions = {
+    swaggerUrl: string;
+    domainsDir: string;
+    write?: boolean;
+};
+export declare function extractEndpoints(options: ExtractEndpointsOptions): Promise<void>;

package/dist/src/config.d.ts

@@ -0,0 +1,145 @@
+import type { UIMessage } from "ai";
+import type { DatabaseAdapter } from "./adapters/database";
+import type { StorageAdapter } from "./adapters/storage";
+import type { DomainDef } from "./graph/types.ts";
+export type KnowledgeConfig = {
+    swagger?: {
+        url: string;
+    };
+    domains?: Record<string, DomainDef>;
+};
+export type DatabaseConfig = {
+    type: "mssql";
+    connectionString: string;
+};
+export type StorageConfig = {
+    endPoint: string;
+    port: number;
+    useSSL: boolean;
+    accessKey: string;
+    secretKey: string;
+    bucketName?: string;
+};
+export type CortexAgentDefinition = {
+    systemPrompt: string | ((session: Record<string, unknown> | null) => string | Promise<string>);
+    tools?: Record<string, unknown>;
+    backendFetch?: {
+        baseUrl: string;
+        apiKey: string;
+        headers?: Record<string, string>;
+        transformRequestBody?: (body: Record<string, unknown>, context: {
+            token: string;
+        }) => Promise<Record<string, unknown>>;
+    };
+    loadSessionData?: (token: string) => Promise<Record<string, unknown>>;
+    onToolCall?: (toolCall: {
+        toolName: string;
+        toolCallId: string;
+        args: Record<string, unknown>;
+    }) => void;
+    onStreamFinish?: (result: {
+        messages: UIMessage[];
+        isAborted: boolean;
+    }) => void;
+    model?: {
+        baseURL: string;
+        apiKey: string;
+        modelName: string;
+        providerName?: string;
+    };
+    embedding?: {
+        baseURL: string;
+        apiKey: string;
+        modelName: string;
+        dimension: number;
+    };
+    neo4j?: {
+        url: string;
+        user: string;
+        password: string;
+    };
+    reranker?: {
+        url: string;
+        apiKey: string;
+    };
+    knowledge?: KnowledgeConfig | null;
+};
+export type ResolvedCortexAgentConfig = {
+    db: DatabaseAdapter;
+    storage: StorageAdapter;
+    model: {
+        baseURL: string;
+        apiKey: string;
+        modelName: string;
+        providerName?: string;
+    };
+    embedding: {
+        baseURL: string;
+        apiKey: string;
+        modelName: string;
+        dimension: number;
+    };
+    neo4j: {
+        url: string;
+        user: string;
+        password: string;
+    };
+    reranker?: {
+        url: string;
+        apiKey: string;
+    };
+    systemPrompt: string | ((session: Record<string, unknown> | null) => string | Promise<string>);
+    tools?: Record<string, unknown>;
+    backendFetch?: {
+        baseUrl: string;
+        apiKey: string;
+        headers?: Record<string, string>;
+        transformRequestBody?: (body: Record<string, unknown>, context: {
+            token: string;
+        }) => Promise<Record<string, unknown>>;
+    };
+    loadSessionData?: (token: string) => Promise<Record<string, unknown>>;
+    onToolCall?: (toolCall: {
+        toolName: string;
+        toolCallId: string;
+        args: Record<string, unknown>;
+    }) => void;
+    onStreamFinish?: (result: {
+        messages: UIMessage[];
+        isAborted: boolean;
+    }) => void;
+    knowledge?: KnowledgeConfig;
+};
+export type CortexConfig = {
+    database: DatabaseConfig;
+    storage: StorageConfig;
+    auth: {
+        jwksUri: string;
+        issuer: string;
+        tokenExtractor?: (req: Request) => string | null;
+        cookieName?: string;
+    };
+    model: {
+        baseURL: string;
+        apiKey: string;
+        modelName: string;
+        providerName?: string;
+    };
+    embedding: {
+        baseURL: string;
+        apiKey: string;
+        modelName: string;
+        dimension: number;
+    };
+    neo4j: {
+        url: string;
+        user: string;
+        password: string;
+    };
+    reranker?: {
+        url: string;
+        apiKey: string;
+    };
+    knowledge?: KnowledgeConfig;
+    agents: Record<string, CortexAgentDefinition>;
+};

package/dist/src/db/migrate.d.ts

@@ -0,0 +1 @@
+export declare function runMigrations(connectionString: string): Promise<void>;