@m6d/cortex-server 1.8.0 → 2.0.1

package/dist/src/lib/graph/generate-cypher.d.ts

@@ -1,22 +0,0 @@
-/**
- * Transforms declarative DomainDef into idempotent MERGE-based Cypher.
- *
- * Returns two phases:
- *   - `nodes`  -- MERGE statements that create/update Domain, Concept, Endpoint,
- *                 Service, and Rule nodes.
- *   - `edges`  -- MATCH+MERGE statements that wire up relationships between nodes.
- *
- * The caller MUST run all `nodes` from every module before running any `edges`,
- * because edges may reference nodes defined in a different module (e.g. a Rule
- * in the leaves module that GOVERNS a Concept created by the servicing module).
- */
-import type { DomainDef } from "./types.ts";
-export type GeneratedCypher = {
-    nodes: string[];
-    edges: string[];
-};
-export declare function generateCypher(data: DomainDef): {
-    nodes: string[];
-    edges: string[];
-};
-export declare function toCypherScript(data: DomainDef): string;

package/dist/src/lib/graph/seed.d.ts

@@ -1,19 +0,0 @@
-/**
- * Seed orchestrator for the knowledge graph.
- *
- * Validates domains, generates Cypher, executes against Neo4j,
- * and generates concept embeddings. All configuration is passed
- * explicitly — no environment variables or Convex dependencies.
- */
-import type { EmbeddingModel } from "ai";
-import type { Neo4jConfig } from "./neo4j.ts";
-import type { DomainDef } from "./types.ts";
-export type EmbeddingConfig = {
-    model: EmbeddingModel;
-    dimension: number;
-};
-export type SeedGraphConfig = {
-    neo4j: Neo4jConfig;
-    embedding: EmbeddingConfig;
-};
-export declare function seedGraph(config: SeedGraphConfig, domains: Record<string, DomainDef>): Promise<void>;

package/dist/src/lib/graph/validate.d.ts

@@ -1,2 +0,0 @@
-import type { DomainDef } from "./types.ts";
-export declare function validateDomain(data: DomainDef): string[];

package/dist/src/lib/routes/index.d.ts

@@ -1,4 +0,0 @@
-export { createThreadRoutes } from "./threads.ts";
-export { createChatRoutes } from "./chat.ts";
-export { createFileRoutes } from "./files.ts";
-export { createWsRoute } from "./ws.ts";

package/dist/src/lib/ws/events.d.ts

@@ -1,39 +0,0 @@
-import type { ThreadSummary } from "../types.ts";
-export type ThreadCreatedEvent = {
-    type: "thread:created";
-    payload: {
-        thread: ThreadSummary;
-    };
-};
-export type ThreadDeletedEvent = {
-    type: "thread:deleted";
-    payload: {
-        threadId: string;
-    };
-};
-export type ThreadTitleUpdatedEvent = {
-    type: "thread:title-updated";
-    payload: {
-        thread: ThreadSummary;
-    };
-};
-export type ThreadRunStartedEvent = {
-    type: "thread:run-started";
-    payload: {
-        thread: ThreadSummary;
-    };
-};
-export type ThreadRunFinishedEvent = {
-    type: "thread:run-finished";
-    payload: {
-        thread: ThreadSummary;
-    };
-};
-export type ThreadMessagesUpdatedEvent = {
-    type: "thread:messages-updated";
-    payload: {
-        threadId: string;
-        thread: ThreadSummary;
-    };
-};
-export type WsEvent = ThreadCreatedEvent | ThreadDeletedEvent | ThreadTitleUpdatedEvent | ThreadRunStartedEvent | ThreadRunFinishedEvent | ThreadMessagesUpdatedEvent;

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

@@ -1,3 +0,0 @@
-export { addConnection, removeConnection, getConnections } from "./connections.ts";
-export { notify } from "./notify.ts";
-export type { WsEvent, ThreadCreatedEvent, ThreadDeletedEvent, ThreadTitleUpdatedEvent, ThreadRunStartedEvent, ThreadRunFinishedEvent, ThreadMessagesUpdatedEvent, } from "./events.ts";

package/dist/src/lib/ws/notify.d.ts

@@ -1,2 +0,0 @@
-import type { WsEvent } from "./events.ts";
-export declare function notify(userId: string, agentId: string, event: WsEvent): void;

package/src/lib/adapters/database.ts

@@ -1,48 +0,0 @@
-import type { ToolUIPart, UIMessage } from "ai";
-import type { Thread, StoredMessage, CapturedFileInput, TokenUsage } from "../types";
-import type { ThreadContextMeta } from "../ai/context/types.ts";
-
-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>;
-        touch(threadId: string): Promise<Thread>;
-        updateTitle(threadId: string, title: string): Promise<void>;
-        updateSession(threadId: string, session: Record<string, unknown>): Promise<void>;
-        updateContextMeta(threadId: string, meta: ThreadContextMeta): Promise<void>;
-    };
-    messages: {
-        list(userId: string, threadId: string, opts?: { limit?: number }): Promise<StoredMessage[]>;
-        upsert(threadId: string, messages: UIMessage[]): Promise<void>;
-    };
-    llmRequests: {
-        insert(
-            requests: {
-                messageId: string;
-                stepNumber: number;
-                prompt: string;
-                output: string | null;
-                tokenUsage: TokenUsage | null;
-            }[],
-        ): Promise<void>;
-        listByMessageId(messageId: string): Promise<
-            {
-                id: string;
-                prompt: string;
-                output: string | null;
-                tokenUsage: TokenUsage | null;
-            }[]
-        >;
-    };
-    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/lib/adapters/mssql.ts

@@ -1,231 +0,0 @@
-import type { ToolUIPart, UIMessage } from "ai";
-import { and, asc, desc, eq, getColumns, inArray, type InferInsertModel } from "drizzle-orm";
-import { drizzle } from "drizzle-orm/node-mssql";
-import { threads, messages, capturedFiles, llmRequests } from "../db/schema";
-import type { DatabaseAdapter } from "./database";
-import type { StorageAdapter } from "./storage";
-import type { Thread, CapturedFileInput, MessageMetadata } from "../types";
-import type { ThreadContextMeta } from "../ai/context/types.ts";
-
-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.updatedAt), 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 touch(threadId: string) {
-                const result = await db
-                    .update(threads)
-                    .set({ updatedAt: new Date() })
-                    .where(eq(threads.id, threadId))
-                    .output()
-                    .execute();
-
-                return result[0] as Thread;
-            },
-
-            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();
-            },
-
-            async updateContextMeta(threadId: string, meta: ThreadContextMeta) {
-                await db
-                    .update(threads)
-                    .set({ contextMeta: meta })
-                    .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, messagesToUpsert: UIMessage<MessageMetadata>[]) {
-                const ids = messagesToUpsert.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 = messagesToUpsert.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 = messagesToUpsert.filter((x) => existingIds.includes(x.id));
-                for (const message of existingMessages) {
-                    await db
-                        .update(messages)
-                        .set({
-                            content: message,
-                            text: message.parts.find((x) => x.type === "text")?.text,
-                        })
-                        .where(eq(messages.id, message.id))
-                        .execute();
-                }
-            },
-        },
-
-        llmRequests: {
-            async insert(requests) {
-                if (!requests.length) return;
-
-                await db
-                    .insert(llmRequests)
-                    .values(
-                        requests.map(
-                            (r) =>
-                                ({
-                                    messageId: r.messageId,
-                                    stepNumber: r.stepNumber,
-                                    prompt: r.prompt,
-                                    output: r.output,
-                                    tokenUsage: r.tokenUsage,
-                                }) satisfies InferInsertModel<typeof llmRequests>,
-                        ),
-                    )
-                    .execute();
-            },
-
-            async listByMessageId(messageId) {
-                return await db
-                    .select({
-                        id: llmRequests.id,
-                        prompt: llmRequests.prompt,
-                        output: llmRequests.output,
-                        tokenUsage: llmRequests.tokenUsage,
-                    })
-                    .from(llmRequests)
-                    .where(eq(llmRequests.messageId, messageId))
-                    .orderBy(asc(llmRequests.stepNumber))
-                    .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/lib/ai/active-streams.ts

@@ -1,123 +0,0 @@
-type ActiveStream = {
-    id: string;
-    abortController: AbortController;
-    buffer: string[];
-    subscribers: Set<ReadableStreamDefaultController<string>>;
-    isComplete: boolean;
-};
-
-const streams = new Map<string, ActiveStream>();
-
-export function registerStream(threadId: string, abortController: AbortController) {
-    const existing = streams.get(threadId);
-    if (existing) {
-        existing.abortController.abort();
-        for (const controller of existing.subscribers) {
-            try {
-                controller.close();
-            } catch {
-                /* already closed */
-            }
-        }
-        streams.delete(threadId);
-    }
-
-    const entry: ActiveStream = {
-        id: crypto.randomUUID(),
-        abortController,
-        buffer: [],
-        subscribers: new Set(),
-        isComplete: false,
-    };
-
-    streams.set(threadId, entry);
-    return entry;
-}
-
-export function attachSseStream(threadId: string, sseStream: ReadableStream<string>) {
-    const entry = streams.get(threadId);
-    if (!entry) return;
-
-    const reader = sseStream.getReader();
-    (async function consume() {
-        try {
-            while (true) {
-                const { done, value } = await reader.read();
-                if (done) break;
-                entry.buffer.push(value);
-                for (const controller of entry.subscribers) {
-                    try {
-                        controller.enqueue(value);
-                    } catch {
-                        /* subscriber cancelled */
-                    }
-                }
-            }
-        } catch {
-            /* stream aborted or errored */
-        } finally {
-            entry.isComplete = true;
-            for (const controller of entry.subscribers) {
-                try {
-                    controller.close();
-                } catch {
-                    /* already closed */
-                }
-            }
-        }
-    })();
-}
-
-export function subscribe(threadId: string) {
-    const entry = streams.get(threadId);
-    if (!entry) return null;
-
-    let savedController: ReadableStreamDefaultController<string>;
-
-    return new ReadableStream<string>({
-        start(controller) {
-            savedController = controller;
-            controller.enqueue("[START]"); // XXX: we need to add this flag for an immediate response for the subscriber, otherwise we'd have to wait for the first token from the llm.
-            for (const chunk of entry.buffer) {
-                controller.enqueue(chunk);
-            }
-            if (entry.isComplete) {
-                controller.close();
-                return;
-            }
-            entry.subscribers.add(controller);
-        },
-        cancel() {
-            entry.subscribers.delete(savedController);
-        },
-    });
-}
-
-export function abortStream(threadId: string) {
-    const entry = streams.get(threadId);
-    if (!entry) return false;
-    queueMicrotask(() => entry.abortController.abort());
-    return true;
-}
-
-export function isStreamRunning(threadId: string) {
-    const entry = streams.get(threadId);
-    return entry ? !entry.isComplete : false;
-}
-
-export function removeStream(threadId: string, streamId?: string) {
-    const entry = streams.get(threadId);
-    if (!entry) return;
-    if (streamId && entry.id !== streamId) return;
-
-    if (entry) {
-        for (const controller of entry.subscribers) {
-            try {
-                controller.close();
-            } catch {
-                /* already closed */
-            }
-        }
-    }
-    streams.delete(threadId);
-}

package/src/lib/ai/context/index.ts

@@ -1,80 +0,0 @@
-export type { ContextConfig, ThreadContextMeta } from "./types.ts";
-export { DEFAULT_CONTEXT_CONFIG } from "./types.ts";
-export {
-    CHARS_PER_TOKEN,
-    estimateTokens,
-    estimateMessageTokens,
-    estimateMessagesTokens,
-} from "./token-estimator.ts";
-export { compressToolResults, smartStructuralCompress, summarizeValue } from "./compressor.ts";
-export { summarizeMessages } from "./summarizer.ts";
-export { buildContextMessages, trimMessagesToFit } from "./builder.ts";
-export {
-    compressIntraTurnToolResults,
-    estimateToolResultTokens,
-    summarizeOldStepResults,
-} from "./intra-turn-compressor.ts";
-
-import type { UIMessage } from "ai";
-import type { ResolvedCortexAgentConfig } from "../../config.ts";
-import type { Thread } from "../../types.ts";
-import type { ThreadContextMeta } from "./types.ts";
-import { estimateMessagesTokens } from "./token-estimator.ts";
-import { summarizeMessages } from "./summarizer.ts";
-
-/**
- * Post-response context optimization.
- * Called fire-and-forget from onFinish — summarizes older messages
- * when token usage exceeds the configured threshold.
- */
-export async function optimizeThreadContext(
-    thread: Thread,
-    messages: UIMessage[],
-    config: ResolvedCortexAgentConfig,
-) {
-    const contextConfig = config.context;
-
-    // 1. Estimate tokens for all messages
-    const estimates = estimateMessagesTokens(messages);
-    const totalEstimatedTokens = estimates.reduce((sum, e) => sum + e.tokens, 0);
-
-    // 2. Check if over summarization threshold
-    const threshold = contextConfig.maxContextTokens * contextConfig.summarizationThreshold;
-
-    if (totalEstimatedTokens <= threshold) {
-        // Update token estimate but skip summarization
-        const meta: ThreadContextMeta = {
-            summary: thread.contextMeta?.summary ?? null,
-            summaryUpToMessageId: thread.contextMeta?.summaryUpToMessageId ?? null,
-            totalEstimatedTokens,
-            lastOptimizedAt: new Date().toISOString(),
-        };
-        await config.db.threads.updateContextMeta(thread.id, meta);
-        return;
-    }
-
-    // 3. Keep the most recent messages unsummarized (they're the hot context)
-    const recentCount = Math.min(contextConfig.recentMessagesToKeep, messages.length);
-    const messagesToSummarize = messages.slice(0, messages.length - recentCount);
-
-    if (messagesToSummarize.length === 0) return;
-
-    // 4. Determine model config for summarization
-    const modelConfig = contextConfig.summarizationModel ?? config.model;
-
-    // 5. Generate summary incorporating any existing summary
-    const existingSummary = thread.contextMeta?.summary ?? null;
-
-    const summary = await summarizeMessages(messagesToSummarize, existingSummary, modelConfig);
-
-    // 6. Update thread context meta
-    const lastSummarizedMessage = messagesToSummarize.at(-1);
-    const meta = {
-        summary,
-        summaryUpToMessageId: lastSummarizedMessage?.id ?? null,
-        totalEstimatedTokens,
-        lastOptimizedAt: new Date().toISOString(),
-    } satisfies ThreadContextMeta;
-
-    await config.db.threads.updateContextMeta(thread.id, meta);
-}

package/src/lib/ai/tools/capture-files.tool.ts

@@ -1,20 +0,0 @@
-import { tool } from "ai";
-import z from "zod";
-
-export const captureFilesTool = tool({
-    description: "Let the user upload a file",
-    inputSchema: z.object({
-        files: z.array(
-            z.object({
-                label: z
-                    .string()
-                    .describe("A label to view to the user to know what file they need to upload"),
-                id: z
-                    .string()
-                    .describe(
-                        "An ID to the file for you to use it when calling apis or later processing",
-                    ),
-            }),
-        ),
-    }),
-});