@m6d/cortex-server 1.8.0 → 2.0.1

package/src/lib/db/schema.pg.ts

@@ -0,0 +1,95 @@
+import { ATTACHMENT_STATUSES } from "@cortex/contracts/wire";
+import {
+    index,
+    integer,
+    jsonb,
+    pgSchema,
+    text,
+    timestamp,
+    uuid,
+    varchar,
+} from "drizzle-orm/pg-core";
+import type { ChatMessage, TokenUsage } from "@/types";
+import type { ThreadContextMeta } from "@/ai/context/types";
+
+/**
+ * The Postgres twin of `schema.mssql.ts`. Drizzle types its schemas per dialect,
+ * so the two cannot be shared — `schema.parity.test.ts` asserts at compile time
+ * that they still infer the same rows, which is what the rest of the code sees.
+ */
+
+export const aiSchema = pgSchema("ai");
+
+const auditColumns = {
+    createdAt: timestamp({ mode: "date", withTimezone: true })
+        .$default(() => new Date())
+        .notNull(),
+    updatedAt: timestamp({ mode: "date", withTimezone: true })
+        .$default(() => new Date())
+        .$onUpdate(() => new Date())
+        .notNull(),
+};
+
+export const threads = aiSchema.table("threads", {
+    id: uuid().defaultRandom().primaryKey(),
+    userId: varchar({ length: 255 }).notNull(),
+    agentId: varchar({ length: 128 }).notNull().default("default"),
+    title: varchar({ length: 256 }),
+    session: jsonb().$type<Record<string, unknown>>(),
+    contextMeta: jsonb().$type<ThreadContextMeta>(),
+    ...auditColumns,
+});
+
+export const messages = aiSchema.table("messages", {
+    id: varchar({ length: 128 }).primaryKey(),
+    threadId: uuid()
+        .references(() => threads.id, { onDelete: "cascade" })
+        .notNull(),
+    text: text(),
+    content: jsonb().notNull().$type<ChatMessage>(),
+    /**
+     * Position within the insert batch that wrote the row. A turn commits
+     * several rows at once, so they share a `createdAt`; the transcript orders
+     * on (createdAt, ordinal) to keep them in the order the turn produced them.
+     */
+    ordinal: integer().notNull().default(0),
+    role: varchar({
+        enum: ["system", "user", "assistant", "tool"],
+        length: 16,
+    }).notNull(),
+    ...auditColumns,
+});
+
+export const llmRequests = aiSchema.table("llm_requests", {
+    id: uuid().defaultRandom().primaryKey(),
+    messageId: varchar({ length: 128 })
+        .references(() => messages.id, { onDelete: "cascade" })
+        .notNull(),
+    stepNumber: integer().notNull(),
+    prompt: text().notNull(),
+    output: text(),
+    tokenUsage: jsonb().$type<TokenUsage>(),
+});
+
+export const attachments = aiSchema.table(
+    "attachments",
+    {
+        id: uuid().defaultRandom().primaryKey(),
+        threadId: uuid()
+            .references(() => threads.id, { onDelete: "cascade" })
+            .notNull(),
+        userId: varchar({ length: 255 }).notNull(),
+        messageId: varchar({ length: 128 }).references(() => messages.id),
+        filename: varchar({ length: 2048 }).notNull(),
+        contentType: varchar({ length: 256 }).notNull(),
+        sizeBytes: integer().notNull(),
+        storageKey: varchar({ length: 512 }).notNull(),
+        status: varchar({
+            enum: ATTACHMENT_STATUSES,
+            length: 16,
+        }).notNull(),
+        description: text(),
+        ...auditColumns,
+    },
+    (table) => [index("attachments_thread_id_index").on(table.threadId)],
+);

package/src/lib/factory.ts

@@ -1,21 +1,24 @@
 import { Hono } from "hono";
 import { websocket } from "hono/bun";
-import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
-import type { CortexConfig, ResolvedCortexAgentConfig } from "./config.ts";
-import { DEFAULT_CONTEXT_CONFIG } from "./ai/context/types.ts";
-import type { ContextConfig } from "./ai/context/types.ts";
-import type { AppEnv, CortexAppEnv } from "./types.ts";
-import type { DomainDef } from "./graph/types.ts";
-import { createUserLoaderMiddleware } from "./auth/middleware.ts";
-import { createThreadRoutes } from "./routes/threads.ts";
-import { createChatRoutes } from "./routes/chat.ts";
-import { createFileRoutes } from "./routes/files.ts";
-import { createWsRoute } from "./routes/ws.ts";
-import { runMigrations } from "./db/migrate.ts";
-import { createMssqlAdapter } from "./adapters/mssql.ts";
-import { createMinioAdapter } from "./adapters/minio.ts";
-import { seedGraph as seedGraphFn } from "./graph/seed.ts";
-import { extractEndpoints as extractEndpointsFn } from "./cli/extract-endpoints.ts";
+import type { CortexConfig, ResolvedCortexAgentConfig } from "./config";
+import { DEFAULT_CONTEXT_CONFIG } from "./ai/context/types";
+import type { ContextConfig } from "./ai/context/types";
+import type { AppEnv, CortexAppEnv } from "./types";
+import { createUserLoaderMiddleware } from "./auth/middleware";
+import { createThreadRoutes } from "./routes/threads";
+import { createChatRoutes } from "./routes/chat";
+import { createFileRoutes } from "./routes/files";
+import { createWsRoute } from "./routes/ws";
+import { runMigrations } from "./db/migrate";
+import { configureRunCoordination } from "./ai/active-runs";
+import { createRedisRuns } from "./ai/redis-runs";
+import { getRedisConnections } from "./redis";
+import { createMssqlAdapter } from "./adapters/database/mssql/index";
+import { createPostgresAdapter } from "./adapters/database/postgres/index";
+import { createMinioAdapter } from "./adapters/storage/minio";
+import { ControlCenterClient } from "./cc/client";
+import { getControlCenterConfig } from "./cc/config-cache";
+import { AGENT_SLUG_PATTERN } from "./cc/types";
 
 export type CortexInstance = {
     serve(): Promise<{
@@ -24,39 +27,26 @@ export type CortexInstance = {
         fetch: Hono<AppEnv>["fetch"];
         websocket: typeof websocket;
     }>;
-    seedGraph(): Promise<void>;
-    extractEndpoints(options: { domainsDir: string; write?: boolean }): Promise<void>;
 };
 
 export function createCortex(config: CortexConfig) {
-    function collectAllDomains() {
-        const all: Record<string, DomainDef> = {};
-        if (config.knowledge?.domains) Object.assign(all, config.knowledge.domains);
-        for (const agent of Object.values(config.agents)) {
-            if (agent.knowledge && agent.knowledge.domains) {
-                Object.assign(all, agent.knowledge.domains);
-            }
-        }
-        return all;
-    }
-
-    function collectAllSwaggerUrls() {
-        const urls = new Set<string>();
-        if (config.knowledge?.swagger?.url) urls.add(config.knowledge.swagger.url);
-        for (const agent of Object.values(config.agents)) {
-            if (agent.knowledge && agent.knowledge.swagger?.url) {
-                urls.add(agent.knowledge.swagger.url);
-            }
-        }
-        return [...urls];
-    }
-
     return {
         async serve() {
-            const storage = createMinioAdapter(config.storage);
-            const db = createMssqlAdapter(config.database.connectionString, storage);
+            const storage = config.storage ? createMinioAdapter(config.storage) : undefined;
+            const createAdapter =
+                config.database.type === "postgres" ? createPostgresAdapter : createMssqlAdapter;
+            const db = createAdapter(config.database.connectionString, storage);
+            const ccClient = config.controlCenter
+                ? new ControlCenterClient(config.controlCenter)
+                : null;
+
+            if (config.redis) {
+                configureRunCoordination(
+                    createRedisRuns(getRedisConnections(config.redis.url), config.redis),
+                );
+            }
 
-            await runMigrations(config.database.connectionString);
+            await runMigrations(config.database);
 
             const app = new Hono<AppEnv>();
 
@@ -71,7 +61,14 @@ export function createCortex(config: CortexConfig) {
 
             agentApp.use("*", async function (c, next) {
                 const agentId = c.req.param("agentId") as string;
-                const agentDef = config.agents[agentId];
+                // An id with no local entry may still be an agent published on the
+                // Control Center: existence is checked against it (ETag-cached, so
+                // usually a 304), which makes publishing there the only allowlist.
+                let agentDef = config.agents?.[agentId];
+                if (!agentDef && ccClient && AGENT_SLUG_PATTERN.test(agentId)) {
+                    const ccConfig = await getControlCenterConfig(ccClient, agentId);
+                    if (ccConfig) agentDef = {};
+                }
                 if (!agentDef) return c.json({ error: "Agent not found" }, 404);
 
                 const resolvedContext: ContextConfig = {
@@ -81,13 +78,16 @@ export function createCortex(config: CortexConfig) {
                 };
 
                 const resolvedConfig: ResolvedCortexAgentConfig = {
+                    agentId,
                     db,
                     storage,
                     model: agentDef.model ?? config.model,
                     fastModel: agentDef.fastModel ?? config.fastModel,
+                    vision: agentDef.vision ?? config.vision,
                     embedding: agentDef.embedding ?? config.embedding,
                     neo4j: agentDef.neo4j ?? config.neo4j,
                     reranker: agentDef.reranker ?? config.reranker,
+                    controlCenter: config.controlCenter,
                     knowledge:
                         agentDef.knowledge === null
                             ? undefined
@@ -123,50 +123,5 @@ export function createCortex(config: CortexConfig) {
                 websocket,
             };
         },
-
-        async seedGraph() {
-            const domains = collectAllDomains();
-            if (!Object.keys(domains).length) {
-                throw new Error("No domains found in knowledge config");
-            }
-            if (!config.neo4j) {
-                throw new Error("neo4j config is required for seedGraph");
-            }
-            if (!config.embedding) {
-                throw new Error("embedding config is required for seedGraph");
-            }
-
-            const provider = createOpenAICompatible({
-                name: "embedding-provider",
-                baseURL: config.embedding.baseURL,
-                apiKey: config.embedding.apiKey,
-            });
-
-            await seedGraphFn(
-                {
-                    neo4j: config.neo4j,
-                    embedding: {
-                        model: provider.textEmbeddingModel(config.embedding.modelName),
-                        dimension: config.embedding.dimension,
-                    },
-                },
-                domains,
-            );
-        },
-
-        async extractEndpoints(options) {
-            const swaggerUrls = collectAllSwaggerUrls();
-            if (!swaggerUrls.length) {
-                throw new Error("No swagger URLs found in knowledge config");
-            }
-
-            for (const swaggerUrl of swaggerUrls) {
-                await extractEndpointsFn({
-                    swaggerUrl,
-                    domainsDir: options.domainsDir,
-                    write: options.write ?? true,
-                });
-            }
-        },
     } satisfies CortexInstance;
 }

package/src/lib/graph/index.ts

@@ -1,47 +1,19 @@
-// Types
-export type {
-    EndpointScalarType,
-    EndpointProperty,
-    ResponseKind,
-    AutoGenerated,
-    ConceptDef,
-    EndpointDef,
-    EndpointInput,
-    ServiceDef,
-    RuleDef,
-    DomainDef,
-} from "./types.ts";
-
-// Helpers
-export {
-    defineConcept,
-    defineRule,
-    defineService,
-    defineDomain,
-    defineEndpoint,
-} from "./helpers.ts";
-
-// Cypher generation
-export type { GeneratedCypher } from "./generate-cypher.ts";
-export { generateCypher, toCypherScript } from "./generate-cypher.ts";
-
-// Validation
-export { validateDomain } from "./validate.ts";
-
-// Neo4j client
-export type { Neo4jConfig, Neo4jClient } from "./neo4j.ts";
-export { createNeo4jClient } from "./neo4j.ts";
-
-// Seed orchestrator
-export type { EmbeddingConfig, SeedGraphConfig } from "./seed.ts";
-export { seedGraph } from "./seed.ts";
+/**
+ * The graph contract lives in `@cortex/contracts/graph` (internal/contracts),
+ * because `@m6d/cortex-cli` writes the graph this package reads and the two are
+ * installed separately (each vendors its own copy at pack time). It is
+ * re-exported here so authoring a project's domains still needs exactly one
+ * import path — nothing about the public surface moved.
+ */
+export * from "@cortex/contracts/graph";
 
-// Graph resolver
+// Graph resolver — the reader, and the one part of the graph that is this
+// package's own.
 export type {
     RerankerConfig,
     ResolverConfig,
     ResolvedEndpoint,
     ResolvedService,
     ResolvedContext,
-} from "./resolver.ts";
-export { resolveFromGraph } from "./resolver.ts";
+} from "./resolver";
+export { resolveFromGraph } from "./resolver";