@m6d/cortex-server 2.3.0 → 2.5.0

package/dist/src/lib/db/schema.mssql.d.ts

@@ -101,6 +101,22 @@ export declare const threads: import("drizzle-orm/mssql-core").MsSqlTableWithCol
             identity: undefined;
             generated: undefined;
         }, {}>;
+        isTest: import("drizzle-orm/mssql-core").MsSqlColumn<{
+            name: string;
+            tableName: "threads";
+            dataType: "boolean";
+            data: boolean;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
         session: import("drizzle-orm/mssql-core").MsSqlColumn<{
             name: string;
             tableName: "threads";
@@ -573,3 +589,148 @@ export declare const attachments: import("drizzle-orm/mssql-core").MsSqlTableWit
     };
     dialect: "mssql";
 }>;
+/**
+ * Events awaiting the cc sync flusher. Insertion order (the identity id) is
+ * flush order; `ack` deletes.
+ */
+/** Single row naming this database's generation. `epoch` is minted on first
+ * flush and changes only when the database is recreated, letting cc tell a
+ * reset outbox sequence from a stale sync batch. */
+export declare const syncMeta: import("drizzle-orm/mssql-core").MsSqlTableWithColumns<{
+    name: "sync_meta";
+    schema: "ai";
+    columns: {
+        id: import("drizzle-orm/mssql-core").MsSqlColumn<{
+            name: string;
+            tableName: "sync_meta";
+            dataType: "number int32";
+            data: number;
+            driverParam: number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        epoch: import("drizzle-orm/mssql-core").MsSqlColumn<{
+            name: string;
+            tableName: "sync_meta";
+            dataType: "string";
+            data: string;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+    };
+    dialect: "mssql";
+}>;
+export declare const syncOutbox: import("drizzle-orm/mssql-core").MsSqlTableWithColumns<{
+    name: "sync_outbox";
+    schema: "ai";
+    columns: {
+        id: import("drizzle-orm/mssql-core").MsSqlColumn<{
+            name: string;
+            tableName: "sync_outbox";
+            dataType: "number int53";
+            data: number;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: {};
+        }, {}>;
+        event: import("drizzle-orm/mssql-core").MsSqlColumn<{
+            name: string;
+            tableName: "sync_outbox";
+            dataType: "object json";
+            data: {
+                type: "thread.upsert";
+                id: string;
+                agentSlug: string;
+                userId: string;
+                title: string | null;
+                isTest: boolean;
+                createdAt: string;
+                updatedAt: string;
+            } | {
+                type: "thread.delete";
+                id: string;
+            } | {
+                type: "message.upsert";
+                id: string;
+                threadId: string;
+                role: "system" | "user" | "assistant" | "tool";
+                text: string | null;
+                ordinal: number;
+                content: {
+                    [x: string]: unknown;
+                };
+                createdAt: string;
+            } | {
+                type: "usage.record";
+                id: string;
+                messageId: string;
+                threadId: string;
+                stepNumber: number;
+                tokenUsage: {
+                    input: {
+                        noCache: number;
+                        cacheRead: number;
+                        cacheWrite: number;
+                        total: number;
+                    };
+                    output: {
+                        reasoning: number;
+                        text: number;
+                        total: number;
+                    };
+                    total: number;
+                };
+                createdAt: string;
+            };
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+        createdAt: import("drizzle-orm/mssql-core").MsSqlColumn<{
+            name: string;
+            tableName: "sync_outbox";
+            dataType: "object date";
+            data: Date;
+            driverParam: string | Date;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: true;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
+    };
+    dialect: "mssql";
+}>;

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

@@ -100,6 +100,21 @@ export declare const threads: import("drizzle-orm/pg-core").PgTableWithColumns<{
             identity: undefined;
             generated: undefined;
         }>;
+        isTest: import("drizzle-orm/pg-core").PgBuildColumn<"threads", import("drizzle-orm/pg-core").SetHasDefault<import("drizzle-orm/pg-core").SetNotNull<import("drizzle-orm/pg-core").PgBooleanBuilder>>, {
+            name: string;
+            tableName: "threads";
+            dataType: "boolean";
+            data: boolean;
+            driverParam: boolean;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            identity: undefined;
+            generated: undefined;
+        }>;
         session: import("drizzle-orm/pg-core").PgBuildColumn<"threads", import("drizzle-orm/pg-core").Set$Type<import("drizzle-orm/pg-core").PgJsonbBuilder, Record<string, unknown>>, {
             name: string;
             tableName: "threads";
@@ -544,3 +559,187 @@ export declare const attachments: import("drizzle-orm/pg-core").PgTableWithColum
     };
     dialect: "pg";
 }>;
+/**
+ * Events awaiting the cc sync flusher. Insertion order (the bigserial id) is
+ * flush order; `ack` deletes.
+ */
+/** Single row naming this database's generation. `epoch` is minted on first
+ * flush and changes only when the database is recreated, letting cc tell a
+ * reset outbox sequence from a stale sync batch. */
+export declare const syncMeta: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "sync_meta";
+    schema: "ai";
+    columns: {
+        id: import("drizzle-orm/pg-core").PgBuildColumn<"sync_meta", import("drizzle-orm/pg-core").SetIsPrimaryKey<import("drizzle-orm/pg-core").PgIntegerBuilder>, {
+            name: string;
+            tableName: "sync_meta";
+            dataType: "number int32";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            identity: undefined;
+            generated: undefined;
+        }>;
+        epoch: import("drizzle-orm/pg-core").PgBuildColumn<"sync_meta", import("drizzle-orm/pg-core").SetNotNull<import("drizzle-orm/pg-core").PgVarcharBuilder<[string, ...string[]]>>, {
+            name: string;
+            tableName: "sync_meta";
+            dataType: "string";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            identity: undefined;
+            generated: undefined;
+        }>;
+    };
+    dialect: "pg";
+}>;
+export declare const syncOutbox: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "sync_outbox";
+    schema: "ai";
+    columns: {
+        id: import("drizzle-orm/pg-core").PgBuildColumn<"sync_outbox", import("drizzle-orm/pg-core").SetIsPrimaryKey<import("drizzle-orm/pg-core").PgBigSerial53Builder>, {
+            name: string;
+            tableName: "sync_outbox";
+            dataType: "number int53";
+            data: number;
+            driverParam: number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            identity: undefined;
+            generated: undefined;
+        }>;
+        event: import("drizzle-orm/pg-core").PgBuildColumn<"sync_outbox", import("drizzle-orm/pg-core").Set$Type<import("drizzle-orm/pg-core").SetNotNull<import("drizzle-orm/pg-core").PgJsonbBuilder>, {
+            type: "thread.upsert";
+            id: string;
+            agentSlug: string;
+            userId: string;
+            title: string | null;
+            isTest: boolean;
+            createdAt: string;
+            updatedAt: string;
+        } | {
+            type: "thread.delete";
+            id: string;
+        } | {
+            type: "message.upsert";
+            id: string;
+            threadId: string;
+            role: "system" | "user" | "assistant" | "tool";
+            text: string | null;
+            ordinal: number;
+            content: {
+                [x: string]: unknown;
+            };
+            createdAt: string;
+        } | {
+            type: "usage.record";
+            id: string;
+            messageId: string;
+            threadId: string;
+            stepNumber: number;
+            tokenUsage: {
+                input: {
+                    noCache: number;
+                    cacheRead: number;
+                    cacheWrite: number;
+                    total: number;
+                };
+                output: {
+                    reasoning: number;
+                    text: number;
+                    total: number;
+                };
+                total: number;
+            };
+            createdAt: string;
+        }>, {
+            name: string;
+            tableName: "sync_outbox";
+            dataType: "object json";
+            data: {
+                type: "thread.upsert";
+                id: string;
+                agentSlug: string;
+                userId: string;
+                title: string | null;
+                isTest: boolean;
+                createdAt: string;
+                updatedAt: string;
+            } | {
+                type: "thread.delete";
+                id: string;
+            } | {
+                type: "message.upsert";
+                id: string;
+                threadId: string;
+                role: "system" | "user" | "assistant" | "tool";
+                text: string | null;
+                ordinal: number;
+                content: {
+                    [x: string]: unknown;
+                };
+                createdAt: string;
+            } | {
+                type: "usage.record";
+                id: string;
+                messageId: string;
+                threadId: string;
+                stepNumber: number;
+                tokenUsage: {
+                    input: {
+                        noCache: number;
+                        cacheRead: number;
+                        cacheWrite: number;
+                        total: number;
+                    };
+                    output: {
+                        reasoning: number;
+                        text: number;
+                        total: number;
+                    };
+                    total: number;
+                };
+                createdAt: string;
+            };
+            driverParam: unknown;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            identity: undefined;
+            generated: undefined;
+        }>;
+        createdAt: import("drizzle-orm/pg-core").PgBuildColumn<"sync_outbox", import("drizzle-orm/pg-core").SetNotNull<import("drizzle-orm/pg-core").SetHasRuntimeDefault<import("drizzle-orm/pg-core").PgTimestampBuilder>>, {
+            name: string;
+            tableName: "sync_outbox";
+            dataType: "object date";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            identity: undefined;
+            generated: undefined;
+        }>;
+    };
+    dialect: "pg";
+}>;

package/dist/src/lib/factory.d.ts

@@ -9,6 +9,8 @@ export type CortexInstance = {
         fetch: Hono<AppEnv>["fetch"];
         websocket: typeof websocket;
     }>;
+    /** Stops the cc sync flusher (a no-op before `serve` or without cc). */
+    stop(): void;
 };
 export declare function createCortex(config: CortexConfig): {
     serve(): Promise<{
@@ -17,4 +19,5 @@ export declare function createCortex(config: CortexConfig): {
         fetch: (request: Request, Env?: {} | undefined, executionCtx?: import("hono").ExecutionContext) => Response | Promise<Response>;
         websocket: import("hono/bun").BunWebSocketHandler<import("hono/bun").BunWebSocketData>;
     }>;
+    stop(): void;
 };

package/dist/src/lib/routes/owned-thread.d.ts

@@ -6,12 +6,13 @@ import type { CortexAppEnv } from "../types";
  * would confirm the thread exists, making cross-agent ids probeable.
  */
 export declare function requireOwnedThread(c: Context<CortexAppEnv>, threadId: string): Promise<{
-    id: string;
-    userId: string;
     agentId: string;
+    userId: string;
+    id: string;
     title: string | null;
-    session: Record<string, unknown> | null;
-    contextMeta: import("..").ThreadContextMeta | null;
+    isTest: boolean;
     createdAt: Date;
     updatedAt: Date;
+    session: Record<string, unknown> | null;
+    contextMeta: import("..").ThreadContextMeta | null;
 }>;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@m6d/cortex-server",
-    "version": "2.3.0",
+    "version": "2.5.0",
     "description": "Reusable AI agent chat server library for Hono + Bun",
     "license": "MIT",
     "type": "module",
@@ -49,7 +49,7 @@
     "devDependencies": {
         "@tanstack/ai": "^0.43.1",
         "@tanstack/ai-openai": "^0.18.0",
-        "@types/bun": "latest",
+        "@types/bun": "1.3.14",
         "@types/minio": "^7.1.1",
         "@types/mssql": "^9.1.5",
         "@types/pg": "^8.15.6",

package/src/lib/adapters/database/index.ts

@@ -1,3 +1,4 @@
+import type { SyncEvent } from "@cortex/contracts/runtime";
 import type {
     Attachment,
     ChatMessage,
@@ -28,7 +29,7 @@ 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>;
+        create(userId: string, agentId: string, options?: { isTest?: boolean }): Promise<Thread>;
         delete(userId: string, threadId: string): Promise<void>;
         touch(threadId: string): Promise<Thread>;
         updateTitle(threadId: string, title: string): Promise<void>;
@@ -45,6 +46,7 @@ export type DatabaseAdapter = {
     };
     llmRequests: {
         insert(
+            threadId: string,
             requests: {
                 messageId: string;
                 stepNumber: number;
@@ -75,4 +77,16 @@ export type DatabaseAdapter = {
         ): Promise<void>;
         remove(id: string, userId: string): Promise<Attachment | undefined>;
     };
+    /**
+     * The cc sync queue. Write sites enqueue through the dialect's
+     * `enqueueSyncEvents` inside their own transaction; the flusher drains via
+     * `peek` (id ascending = insertion order) and `ack` (delete) here.
+     */
+    outbox: {
+        enqueue(events: SyncEvent[]): Promise<void>;
+        peek(limit: number): Promise<{ id: number; event: SyncEvent }[]>;
+        ack(ids: number[]): Promise<void>;
+        /** This database generation's id, minted on first use (see `syncMeta`). */
+        epoch(): Promise<string>;
+    };
 };

package/src/lib/adapters/database/mssql/index.ts

@@ -5,19 +5,28 @@ import { createThreadsRepository } from "./threads";
 import { createMessagesRepository } from "./messages";
 import { createLlmRequestsRepository } from "./llm-requests";
 import { createAttachmentsRepository } from "./attachments";
+import { createOutboxRepository, enqueueSyncEvents } from "./outbox";
 
 /**
  * The MSSQL implementation of the database contract. One repository per table;
  * only threads takes storage, because deleting a thread is the one operation
  * that also has to reach into object storage.
  */
-export function createMssqlAdapter(connectionString: string, storage?: StorageAdapter) {
+export function createMssqlAdapter(
+    connectionString: string,
+    storage?: StorageAdapter,
+    options?: { syncMirror?: boolean },
+) {
     const db = createMssqlDb(connectionString);
+    // Without a Control Center there is no flusher to drain the outbox, so
+    // enqueueing would only grow sync_outbox forever.
+    const enqueue = options?.syncMirror === false ? async () => {} : enqueueSyncEvents;
 
     return {
-        threads: createThreadsRepository(db, storage),
-        messages: createMessagesRepository(db),
-        llmRequests: createLlmRequestsRepository(db),
+        threads: createThreadsRepository(db, storage, enqueue),
+        messages: createMessagesRepository(db, enqueue),
+        llmRequests: createLlmRequestsRepository(db, enqueue),
         attachments: createAttachmentsRepository(db),
+        outbox: createOutboxRepository(db),
     } satisfies DatabaseAdapter;
 }

package/src/lib/adapters/database/mssql/llm-requests.ts

@@ -1,28 +1,48 @@
 import { asc, eq, type InferInsertModel } from "drizzle-orm";
 import { llmRequests } from "@/db/schema.mssql";
+import { usageRecordEvent } from "@/cc/sync-events";
 import type { DatabaseAdapter } from "@/adapters/database/index";
 import type { MssqlDb } from "./client";
+import { enqueueSyncEvents } from "./outbox";
 
-export function createLlmRequestsRepository(db: MssqlDb) {
+export function createLlmRequestsRepository(
+    db: MssqlDb,
+    enqueue: typeof enqueueSyncEvents = enqueueSyncEvents,
+) {
     return {
-        async insert(requests) {
+        async insert(threadId, requests) {
             if (!requests.length) return;
 
-            await db
-                .insert(llmRequests)
-                .values(
-                    requests.map(
-                        (r) =>
-                            ({
+            await db.transaction(async function (tx) {
+                await tx
+                    .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();
+                await enqueue(
+                    tx,
+                    requests
+                        .filter((r) => r.tokenUsage !== null)
+                        .map((r) =>
+                            usageRecordEvent({
+                                threadId,
                                 messageId: r.messageId,
                                 stepNumber: r.stepNumber,
-                                prompt: r.prompt,
-                                output: r.output,
-                                tokenUsage: r.tokenUsage,
-                            }) satisfies InferInsertModel<typeof llmRequests>,
-                    ),
-                )
-                .execute();
+                                tokenUsage: r.tokenUsage!,
+                            }),
+                        ),
+                );
+            });
         },
 
         /** Ordered by step so the inspector replays a turn in the order it ran. */