@m6d/cortex-server 1.7.0 → 2.0.0

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

@@ -0,0 +1,127 @@
+import { Hono } from "hono";
+import { websocket } from "hono/bun";
+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<{
+        app: Hono<AppEnv>;
+        port: number;
+        fetch: Hono<AppEnv>["fetch"];
+        websocket: typeof websocket;
+    }>;
+};
+
+export function createCortex(config: CortexConfig) {
+    return {
+        async serve() {
+            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);
+
+            const app = new Hono<AppEnv>();
+
+            const userLoader = createUserLoaderMiddleware(config.auth);
+            app.use("*", userLoader);
+
+            // Compatibility WebSocket route
+            app.route("/", createWsRoute());
+
+            // Agent-scoped routes
+            const agentApp = new Hono<CortexAppEnv>();
+
+            agentApp.use("*", async function (c, next) {
+                const agentId = c.req.param("agentId") as string;
+                // 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 = {
+                    ...DEFAULT_CONTEXT_CONFIG,
+                    ...config.context,
+                    ...agentDef.context,
+                };
+
+                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
+                            : (agentDef.knowledge ?? config.knowledge),
+                    systemPrompt: agentDef.systemPrompt,
+                    tools: agentDef.tools,
+                    backendFetch: agentDef.backendFetch,
+                    loadSessionData: agentDef.loadSessionData,
+                    resolveRequestContext: agentDef.resolveRequestContext,
+                    onToolCall: agentDef.onToolCall,
+                    onStreamFinish: agentDef.onStreamFinish,
+                    context: resolvedContext,
+                };
+
+                c.set("agentConfig", resolvedConfig);
+                c.set("agentId", agentId);
+                await next();
+            });
+
+            agentApp.route("/", createThreadRoutes());
+            agentApp.route("/", createChatRoutes());
+            agentApp.route("/", createFileRoutes());
+            agentApp.route("/", createWsRoute({ useAgentParam: true }));
+
+            app.route("/agents/:agentId", agentApp);
+
+            const port = config.port ?? 3331;
+
+            return {
+                app,
+                port,
+                fetch: app.fetch,
+                websocket,
+            };
+        },
+    } satisfies CortexInstance;
+}

package/src/lib/graph/index.ts

@@ -0,0 +1,19 @@
+/**
+ * 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 — the reader, and the one part of the graph that is this
+// package's own.
+export type {
+    RerankerConfig,
+    ResolverConfig,
+    ResolvedEndpoint,
+    ResolvedService,
+    ResolvedContext,
+} from "./resolver";
+export { resolveFromGraph } from "./resolver";

package/src/lib/graph/resolver.ts

@@ -0,0 +1,387 @@
+/**
+ * Pre-resolves relevant API endpoints from the Neo4j knowledge graph
+ * using vector similarity search on concept descriptions.
+ *
+ * All configuration is passed explicitly — no hardcoded model references
+ * or environment variables.
+ */
+
+import {
+    GRAPH_SCHEMA,
+    GRAPH_SCHEMA_VERSION,
+    type ConceptDef,
+    type EmbedFn,
+    type Neo4jClient,
+} from "@cortex/contracts/graph";
+
+// The graph's vocabulary, aliased short so the Cypher below still reads as Cypher.
+const { label: L, rel: R, prop: P } = GRAPH_SCHEMA;
+
+/**
+ * Seed data, not schema: the concept a project names to expose its generic
+ * service-request endpoints, which is why it stays here rather than in
+ * `schema.ts` — the seeder writes whatever concepts a domain declares.
+ */
+const SERVICE_REQUEST = "ServiceRequest";
+
+export type RerankerConfig = {
+    url: string;
+    apiKey: string;
+};
+
+export type ResolverConfig = {
+    neo4j: Neo4jClient;
+    embed: EmbedFn;
+    reranker?: RerankerConfig;
+};
+
+type EndpointDependency = {
+    depPath: string;
+    depMethod: string;
+    paramName: string;
+    fromField: string;
+};
+
+type EndpointRelation = "read" | "write";
+
+type RelationType = typeof R.queriedVia | typeof R.mutatedVia;
+
+export type ResolvedEndpoint = {
+    concept: string;
+    relation: EndpointRelation;
+    name: string;
+    path: string;
+    method: string;
+    params: string;
+    body: string;
+    response: string;
+    dependencies: EndpointDependency[];
+    rules: string[];
+    metadata: string;
+};
+
+export type ResolvedService = {
+    concept: string;
+    serviceName: string;
+    builtInId: string;
+    description: string;
+    rules: string[];
+    metadata: string;
+};
+
+export type ResolvedContext = {
+    readEndpoints: ResolvedEndpoint[];
+    writeEndpoints: ResolvedEndpoint[];
+    services: ResolvedService[];
+};
+
+type EndpointRow = {
+    concept: string;
+    relationType: RelationType;
+    name: string;
+    path: string;
+    method: string;
+    params: string | null;
+    body: string | null;
+    response: string | null;
+    metadata: string | null;
+    dependencies: (EndpointDependency | { depPath: null })[];
+    rules: (string | null)[];
+};
+
+type ServiceRow = {
+    concept: string;
+    serviceName: string;
+    builtInId: string;
+    description: string | null;
+    metadata: string | null;
+    rules: (string | null)[];
+};
+
+/**
+ * Cleared only by a restart, which is also the only thing that can change which
+ * schema this process reads with. A re-seed under a running server is the case
+ * this misses, and re-seeding at the same version is the overwhelmingly common one.
+ */
+let versionChecked = false;
+
+/**
+ * `@m6d/cortex-cli` stamps the schema version it seeded onto the graph; this reads
+ * it back before any Cypher below runs. Lazily, on the first resolve rather than at
+ * boot, so a Neo4j that happens to be down cannot stop `serve()`.
+ */
+async function assertGraphVersion(neo4j: Neo4jClient) {
+    if (versionChecked) return;
+
+    const rows: unknown = await neo4j
+        .query(
+            `OPTIONAL MATCH (g:${L.marker}) WITH g LIMIT 1
+             OPTIONAL MATCH (c:${L.concept})
+             RETURN g.${P.version} AS version, count(c) AS concepts`,
+        )
+        .then(JSON.parse)
+        .catch(() => undefined);
+
+    // An unreachable graph answers with an error object rather than a row array.
+    // That is the resolve's own failure to report, not schema skew.
+    if (!Array.isArray(rows)) return;
+
+    // OPTIONAL MATCH answers a missing marker with `null`, not with a missing row.
+    const { version: stamped, concepts } =
+        (rows as { version?: number | null; concepts?: number }[])[0] ?? {};
+    if (stamped === GRAPH_SCHEMA_VERSION) {
+        versionChecked = true;
+        return;
+    }
+
+    // No stamp over an empty graph is a project mid-setup (Neo4j configured, seed
+    // not yet run), not skew: resolve as the empty context it is. Not cached, so
+    // the stamp is validated as soon as a seed lands.
+    if (stamped == null && (concepts ?? 0) === 0) return;
+
+    throw new Error(
+        [
+            stamped == null
+                ? `The Neo4j graph holds data but no schema stamp, and this server reads graph schema v${GRAPH_SCHEMA_VERSION}.`
+                : `The Neo4j graph was written with graph schema v${stamped}, and this server reads v${GRAPH_SCHEMA_VERSION}.`,
+            "Writer and reader disagree on the labels, relationships and property names, so retrieval would return empty or wrong results instead of failing.",
+            "Re-seed the graph with `bunx @m6d/cortex-cli graph seed`, or install the @m6d/cortex-server that matches the graph you have.",
+        ].join(" "),
+    );
+}
+
+export async function resolveFromGraph(prompt: string, config: ResolverConfig) {
+    // Before the first query and outside the catch below: skew is invisible to
+    // every check further down, which is the whole reason it is checked here.
+    await assertGraphVersion(config.neo4j);
+
+    const empty: ResolvedContext = {
+        readEndpoints: [],
+        writeEndpoints: [],
+        services: [],
+    };
+
+    try {
+        const embedding = (await config.embed([prompt]))[0]!;
+
+        const conceptsRaw = await config.neo4j.query(
+            `CALL db.index.vector.queryNodes('${GRAPH_SCHEMA.conceptEmbeddingsIndex}', 10, $embedding)
+             YIELD node, score
+             WHERE score > 0.3
+             RETURN node.${P.name} AS name, node.${P.description} AS description, score
+             ORDER BY score DESC`,
+            { embedding },
+        );
+
+        let concepts = JSON.parse(conceptsRaw) as (Pick<ConceptDef, "name" | "description"> & {
+            score: number;
+        })[];
+
+        if (!Array.isArray(concepts) || concepts.length === 0) {
+            return empty;
+        }
+
+        if (config.reranker) {
+            concepts = await computeRelevanceScores(prompt, concepts, config.reranker);
+        } else {
+            concepts = concepts.slice(0, 3);
+        }
+
+        const conceptNames = concepts.map((c) => c.name);
+
+        const endpointsRaw = await config.neo4j.query(
+            `UNWIND $names AS conceptName
+             MATCH (c:${L.concept} {${P.name}: conceptName})-[:${R.specializes}*0..3]->(ancestor:${L.concept})
+             WITH conceptName, collect(DISTINCT ancestor) AS family
+             UNWIND family AS related
+             MATCH (related)-[rel:${R.queriedVia}|${R.mutatedVia}]->(e:${L.endpoint})
+             WITH conceptName, related, rel, e
+             OPTIONAL MATCH (e)-[d:${R.dependsOn}]->(dep:${L.endpoint})
+             WITH conceptName, related, rel, e,
+                  collect(DISTINCT {
+                      depPath: dep.${P.path},
+                      depMethod: dep.${P.method},
+                      paramName: d.${P.paramName},
+                      fromField: d.${P.fromField}
+                  }) AS dependencies
+             OPTIONAL MATCH (rEndpoint:${L.rule})-[:${R.governs}]->(e)
+             OPTIONAL MATCH (rConcept:${L.rule})-[:${R.governs}]->(related)
+             RETURN conceptName AS concept,
+                    type(rel) AS relationType,
+                    e.${P.name} AS name,
+                    e.${P.path} AS path,
+                    e.${P.method} AS method,
+                    e.${P.params} AS params,
+                    e.${P.body} AS body,
+                    e.${P.response} AS response,
+                    e.${P.metadata} AS metadata,
+                    dependencies,
+                    collect(DISTINCT rEndpoint.${P.description}) +
+                    collect(DISTINCT rConcept.${P.description}) AS rules`,
+            { names: conceptNames },
+        );
+
+        const endpointRows = asArray<EndpointRow>(JSON.parse(endpointsRaw));
+        const allEndpoints = dedupeEndpoints(endpointRows.map(toResolvedEndpoint));
+
+        const servicesRaw = await config.neo4j.query(
+            `UNWIND $names AS conceptName
+             MATCH (c:${L.concept} {${P.name}: conceptName})-[:${R.specializes}*0..3]->(ancestor:${L.concept})
+             WITH conceptName, collect(DISTINCT ancestor) AS family
+             UNWIND family AS related
+             MATCH (related)-[:${R.requestedVia}]->(svc:${L.service})
+             WITH conceptName, related, svc
+             OPTIONAL MATCH (rService:${L.rule})-[:${R.governs}]->(svc)
+             OPTIONAL MATCH (rConcept:${L.rule})-[:${R.governs}]->(related)
+             RETURN conceptName AS concept,
+                    svc.${P.name} AS serviceName,
+                    svc.${P.builtInId} AS builtInId,
+                    svc.${P.description} AS description,
+                    svc.${P.metadata} AS metadata,
+                    collect(DISTINCT rService.${P.description}) +
+                    collect(DISTINCT rConcept.${P.description}) AS rules`,
+            { names: conceptNames },
+        );
+
+        const services = dedupeServices(
+            asArray<ServiceRow>(JSON.parse(servicesRaw)).map(function (row) {
+                return {
+                    concept: row.concept,
+                    serviceName: row.serviceName,
+                    builtInId: row.builtInId,
+                    description: row.description ?? "",
+                    metadata: row.metadata ?? "{}",
+                    rules: row.rules.filter((rule): rule is string => Boolean(rule)),
+                };
+            }),
+        );
+
+        // Service-to-Servicing bridge: if any services were resolved, pull in
+        // the generic Servicing endpoints
+        let servicingEndpoints: ResolvedEndpoint[] = [];
+        if (services.length > 0) {
+            const servicingRaw = await config.neo4j.query(
+                `MATCH (c:${L.concept} {${P.name}: '${SERVICE_REQUEST}'})-[rel:${R.queriedVia}|${R.mutatedVia}]->(e:${L.endpoint})
+                 OPTIONAL MATCH (e)-[d:${R.dependsOn}]->(dep:${L.endpoint})
+                 WITH c, rel, e,
+                      collect(DISTINCT {
+                          depPath: dep.${P.path},
+                          depMethod: dep.${P.method},
+                          paramName: d.${P.paramName},
+                          fromField: d.${P.fromField}
+                      }) AS dependencies
+                 OPTIONAL MATCH (rEndpoint:${L.rule})-[:${R.governs}]->(e)
+                 OPTIONAL MATCH (rConcept:${L.rule})-[:${R.governs}]->(c)
+                 RETURN '${SERVICE_REQUEST}' AS concept,
+                        type(rel) AS relationType,
+                        e.${P.name} AS name,
+                        e.${P.path} AS path,
+                        e.${P.method} AS method,
+                        e.${P.params} AS params,
+                        e.${P.body} AS body,
+                        e.${P.response} AS response,
+                        e.${P.metadata} AS metadata,
+                        dependencies,
+                        collect(DISTINCT rEndpoint.${P.description}) +
+                        collect(DISTINCT rConcept.${P.description}) AS rules`,
+                {},
+            );
+
+            servicingEndpoints = dedupeEndpoints(
+                asArray<EndpointRow>(JSON.parse(servicingRaw)).map(toResolvedEndpoint),
+            );
+        }
+
+        const combinedEndpoints = dedupeEndpoints([...allEndpoints, ...servicingEndpoints]);
+
+        return {
+            readEndpoints: combinedEndpoints.filter((ep) => ep.relation === "read"),
+            writeEndpoints: combinedEndpoints.filter((ep) => ep.relation === "write"),
+            services,
+        } satisfies ResolvedContext;
+    } catch (error) {
+        console.error("Graph resolution failed:", error);
+        return empty;
+    }
+}
+
+function asArray<T>(value: unknown) {
+    return Array.isArray(value) ? (value as T[]) : ([] as T[]);
+}
+
+/** Maps a Cypher row to an endpoint. The string defaults stand in for columns
+ *  Neo4j returns as null, which downstream JSON.parse calls would choke on. */
+function toResolvedEndpoint(row: EndpointRow) {
+    return {
+        concept: row.concept,
+        relation: row.relationType === R.mutatedVia ? ("write" as const) : ("read" as const),
+        name: row.name,
+        path: row.path,
+        method: row.method,
+        params: row.params ?? "[]",
+        body: row.body ?? "[]",
+        response: row.response ?? "[]",
+        metadata: row.metadata ?? "{}",
+        dependencies: row.dependencies.filter(
+            (dep): dep is EndpointDependency => dep.depPath != null,
+        ),
+        rules: row.rules.filter((rule): rule is string => Boolean(rule)),
+    } satisfies ResolvedEndpoint;
+}
+
+function dedupeEndpoints(endpoints: ResolvedEndpoint[]) {
+    const seen = new Set<string>();
+    const deduped: ResolvedEndpoint[] = [];
+
+    for (const ep of endpoints) {
+        const key = `${ep.relation}|${ep.concept}|${ep.method}|${ep.path}`;
+        if (seen.has(key)) continue;
+        seen.add(key);
+        deduped.push(ep);
+    }
+
+    return deduped;
+}
+
+function dedupeServices(services: ResolvedService[]) {
+    const seen = new Set<string>();
+    const deduped: ResolvedService[] = [];
+
+    for (const svc of services) {
+        const key = `${svc.concept}|${svc.builtInId}`;
+        if (seen.has(key)) continue;
+        seen.add(key);
+        deduped.push(svc);
+    }
+
+    return deduped;
+}
+
+async function computeRelevanceScores(
+    prompt: string,
+    concepts: (Pick<ConceptDef, "name" | "description"> & { score: number })[],
+    reranker: RerankerConfig,
+) {
+    const response = await fetch(reranker.url, {
+        method: "POST",
+        headers: {
+            Authorization: `Bearer ${reranker.apiKey}`,
+            "Content-Type": "application/json",
+        },
+        body: JSON.stringify({
+            queries: [prompt],
+            documents: concepts.map((x) => x.description),
+        }),
+    });
+
+    const data = (await response.json()) as { scores: number[] };
+    const scores = data.scores;
+
+    const scoredConcepts = concepts.map((c, idx) => ({
+        ...c,
+        score: scores[idx]!,
+    }));
+
+    scoredConcepts.sort((a, b) => b.score - a.score);
+    return scoredConcepts.slice(0, 3);
+}

package/src/{index.ts → lib/index.ts}

@@ -2,13 +2,21 @@
 export type {
     CortexConfig,
     CortexAgentDefinition,
+    ControlCenterConfig,
     KnowledgeConfig,
     DatabaseConfig,
+    RedisConfig,
     StorageConfig,
     PromptContext,
+    ToolContext,
+    ToolSet,
+    ToolSetFactory,
 } from "./config";
 export { defineAgent } from "./config";
 
+// Provider shape, so a consumer can name what it passes to the model helpers.
+export type { ProviderConfig } from "./ai/helpers";
+
 export type { ContextConfig, ThreadContextMeta } from "./ai/context/types";
 
 // Types consumers may need
@@ -26,13 +34,13 @@ export type {
 export { createRequestInterceptor } from "./ai/interceptors/request-interceptor";
 
 // Tools (consumers may register custom tools or use built-in ones)
-export { captureFilesTool } from "./ai/tools/capture-files.tool";
 export { createQueryGraphTool } from "./ai/tools/query-graph.tool";
-export { createCallEndpointTool } from "./ai/tools/call-endpoint.tool";
 export { createExecuteCodeTool } from "./ai/tools/execute-code.tool";
 
-// Graph (consumers may use independently)
+// Graph (consumers may use independently). The contract itself lives in
+// @cortex/contracts/graph — see ./graph/index — and is re-exported through here.
 export * from "./graph/index";
 
-// WebSocket event types
-export type { WsEvent, ThreadTitleUpdatedEvent } from "./ws/index";
+// The wire contract, re-exported so consumers get it without a second import path.
+// Its home is @cortex/contracts/wire, which the client SDKs compile in too.
+export * from "@cortex/contracts/wire";