@m6d/cortex-server 1.3.0 → 1.4.0

package/src/cli/extract-endpoints.ts

@@ -39,7 +39,7 @@ const AUTO_START = "// @auto-generated-start";
 const AUTO_END = "// @auto-generated-end";
 const MAX_DEPTH = 8;
 
-const toCamelCase = (s: string): string =>
+const toCamelCase = (s: string) =>
     s
         .split(".")
         .map((seg) => seg.replace(/^[A-Z]/, (c) => c.toLowerCase()))
@@ -54,13 +54,13 @@ const dedupe = (items: Prop[]): Prop[] => {
     return items.filter((x) => (seen.has(x.name) ? false : (seen.add(x.name), true)));
 };
 
-function normalizePath(raw: string): string {
+function normalizePath(raw: string) {
     let p = raw.startsWith("/") ? raw : `/${raw}`;
     p = p.replace(/\{([^}:?]+)(?::[^}]+)?\??\}/g, "{$1}").replace(/^\/api(?=\/|$)/i, "") || "/";
     return p.length > 1 ? p.replace(/\/+$/, "") : p;
 }
 
-function walkFiles(dir: string, accept: (filePath: string) => boolean): string[] {
+function walkFiles(dir: string, accept: (filePath: string) => boolean) {
     if (!fs.existsSync(dir)) return [];
     const out: string[] = [];
     function walk(d: string) {
@@ -74,7 +74,7 @@ function walkFiles(dir: string, accept: (filePath: string) => boolean): string[]
     return out;
 }
 
-function endpointFiles(root: string): Map<string, string> {
+function endpointFiles(root: string) {
     const out = new Map<string, string>();
     for (const filePath of walkFiles(root, (p) => p.endsWith(".endpoint.ts"))) {
         const c = fs.readFileSync(filePath, "utf8");
@@ -85,7 +85,7 @@ function endpointFiles(root: string): Map<string, string> {
     return out;
 }
 
-function resolvePointer(doc: unknown, ref: string): unknown {
+function resolvePointer(doc: unknown, ref: string) {
     if (!ref.startsWith("#/")) return null;
     let cur: unknown = doc;
     for (const part of ref.slice(2).split("/")) {
@@ -96,7 +96,7 @@ function resolvePointer(doc: unknown, ref: string): unknown {
     return cur;
 }
 
-function deref(doc: unknown, v: unknown): Obj {
+function deref(doc: unknown, v: unknown) {
     if (!isObj(v)) return {};
     let x = v;
     const seen = new Set<string>();
@@ -108,7 +108,7 @@ function deref(doc: unknown, v: unknown): Obj {
     return x;
 }
 
-function schemaType(s: Obj): string {
+function schemaType(s: Obj) {
     const t = Array.isArray(s.type)
         ? s.type.find((x) => typeof x === "string" && x !== "null")
         : s.type;
@@ -133,7 +133,7 @@ function isJsonNodeSchema(s: Obj) {
     );
 }
 
-function scalarType(s: Obj): string {
+function scalarType(s: Obj) {
     if (Array.isArray(s.enum) && s.enum.every((v) => typeof v === "string")) {
         return s.enum.map((v) => `'${String(v).replace(/'/g, "\\'")}'`).join(" | ");
     }
@@ -149,7 +149,7 @@ function scalarType(s: Obj): string {
     return "unknown";
 }
 
-function toProps(doc: unknown, schemaIn: unknown, depth = 0): Prop[] {
+function toProps(doc: unknown, schemaIn: unknown, depth = 0) {
     if (depth > MAX_DEPTH) return [];
     const s = deref(doc, schemaIn);
     if (isJsonNodeRef(schemaIn) || isJsonNodeSchema(s)) return [];
@@ -198,7 +198,7 @@ function toProp(doc: unknown, name: string, schemaIn: unknown, required: boolean
     return { name, required: req, type: scalarType(s) };
 }
 
-function pickContent(contentIn: unknown): { schema: unknown; mimes: string[] } | null {
+function pickContent(contentIn: unknown) {
     const content = obj(contentIn);
     const mimes = Object.keys(content);
     if (!mimes.length) return null;
@@ -319,7 +319,7 @@ function extractEndpoint(
     method: HttpMethod,
     pathItemIn: unknown,
     operationIn: unknown,
-): Endpoint {
+) {
     const pathItem = obj(pathItemIn);
     const operation = obj(operationIn);
 
@@ -393,10 +393,10 @@ function extractEndpoint(
         responseKind: parsed.responseKind,
         successStatus: parsed.successStatus,
         errorStatuses: parsed.errorStatuses,
-    };
+    } satisfies Endpoint;
 }
 
-function parseSwaggerEndpoints(swagger: unknown): Map<string, Endpoint> {
+function parseSwaggerEndpoints(swagger: unknown) {
     const out = new Map<string, Endpoint>();
     const doc = obj(swagger);
     for (const [route, pathItem] of Object.entries(obj(doc.paths))) {
@@ -410,7 +410,7 @@ function parseSwaggerEndpoints(swagger: unknown): Map<string, Endpoint> {
     return out;
 }
 
-function serializeProps(props: Prop[], depth: number): string {
+function serializeProps(props: Prop[], depth: number) {
     return props
         .map((p) => {
             const indent = "    ".repeat(depth);
@@ -431,7 +431,7 @@ function serializeProps(props: Prop[], depth: number): string {
         .join("\n");
 }
 
-function blockFor(endpoint: Endpoint): string {
+function blockFor(endpoint: Endpoint) {
     return `    autoGenerated: {
         params: [
 ${serializeProps(endpoint.params, 2)}
@@ -461,7 +461,7 @@ function formatGeneratedFiles(cwd: string, filePaths: string[]) {
     }
 }
 
-async function fetchJson(url: string): Promise<unknown> {
+async function fetchJson(url: string) {
     const response = await fetch(url, {
         headers: { Accept: "application/json" },
     });
@@ -471,7 +471,7 @@ async function fetchJson(url: string): Promise<unknown> {
     return response.json();
 }
 
-function resolveEndpoint(key: string, extracted: Map<string, Endpoint>): Endpoint | undefined {
+function resolveEndpoint(key: string, extracted: Map<string, Endpoint>) {
     const [method, route] = key.split(":");
     if (!method || !route) return undefined;
     return (
@@ -483,7 +483,7 @@ function resolveEndpoint(key: string, extracted: Map<string, Endpoint>): Endpoin
     );
 }
 
-export async function extractEndpoints(options: ExtractEndpointsOptions): Promise<void> {
+export async function extractEndpoints(options: ExtractEndpointsOptions) {
     const { swaggerUrl, domainsDir, write = false } = options;
 
     console.log(`Fetching Swagger from ${swaggerUrl}`);

package/src/config.ts

@@ -3,6 +3,7 @@ import type { DatabaseAdapter } from "./adapters/database";
 import type { StorageAdapter } from "./adapters/storage";
 import type { DomainDef } from "./graph/types.ts";
 import type { RequestInterceptorOptions } from "./ai/interceptors/request-interceptor.ts";
+import type { ContextConfig } from "./ai/context/types.ts";
 
 export type KnowledgeConfig = {
     swagger?: { url: string };
@@ -64,6 +65,7 @@ export type CortexAgentDefinition = {
         url: string;
         apiKey: string;
     };
+    context?: Partial<ContextConfig>;
     knowledge?: KnowledgeConfig | null;
 };
 
@@ -110,6 +112,7 @@ export type ResolvedCortexAgentConfig = {
         args: Record<string, unknown>;
     }) => void;
     onStreamFinish?: (result: { messages: UIMessage[]; isAborted: boolean }) => void;
+    context: ContextConfig;
     knowledge?: KnowledgeConfig;
 };
 
@@ -144,6 +147,7 @@ export type CortexConfig = {
         url: string;
         apiKey: string;
     };
+    context?: Partial<ContextConfig>;
     knowledge?: KnowledgeConfig;
     agents: Record<string, CortexAgentDefinition>;
 };

package/src/db/migrations/20260315000000_add_context_meta/migration.sql

@@ -0,0 +1 @@
+ALTER TABLE [ai].[threads] ADD [context_meta] nvarchar(max);

package/src/db/schema.ts

@@ -1,6 +1,8 @@
 import type { ToolUIPart, UIMessage } from "ai";
 import { sql } from "drizzle-orm";
 import { customType, datetime2, index, mssqlSchema, nvarchar } from "drizzle-orm/mssql-core";
+import type { MessageMetadata } from "src/types";
+import type { ThreadContextMeta } from "../ai/context/types.ts";
 
 const uniqueIdentifier = customType<{ data: string }>({
     dataType() {
@@ -28,6 +30,7 @@ export const threads = aiSchema.table("threads", {
     agentId: nvarchar({ length: 128 }).notNull().default("default"),
     title: nvarchar({ length: 256 }),
     session: nvarchar({ mode: "json", length: "max" }).$type<Record<string, unknown>>(),
+    contextMeta: nvarchar({ mode: "json", length: "max" }).$type<ThreadContextMeta>(),
     ...auditColumns,
 });
 
@@ -37,7 +40,9 @@ export const messages = aiSchema.table("messages", {
         .references(() => threads.id, { onDelete: "cascade" })
         .notNull(),
     text: nvarchar({ length: "max" }),
-    content: nvarchar({ mode: "json", length: "max" }).notNull().$type<UIMessage>(),
+    content: nvarchar({ mode: "json", length: "max" })
+        .notNull()
+        .$type<UIMessage<MessageMetadata>>(),
     role: nvarchar({
         enum: ["system", "user", "assistant", "tool"],
         length: 16,

package/src/factory.ts

@@ -2,6 +2,8 @@ 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";
@@ -61,7 +63,7 @@ export function createCortex(config: CortexConfig) {
             const userLoader = createUserLoaderMiddleware(config.auth);
             app.use("*", userLoader);
 
-            // WebSocket route (global, not agent-scoped)
+            // Compatibility WebSocket route
             app.route("/", createWsRoute());
 
             // Agent-scoped routes
@@ -72,6 +74,12 @@ export function createCortex(config: CortexConfig) {
                 const agentDef = config.agents[agentId];
                 if (!agentDef) return c.json({ error: "Agent not found" }, 404);
 
+                const resolvedContext: ContextConfig = {
+                    ...DEFAULT_CONTEXT_CONFIG,
+                    ...config.context,
+                    ...agentDef.context,
+                };
+
                 const resolvedConfig: ResolvedCortexAgentConfig = {
                     db,
                     storage,
@@ -89,6 +97,7 @@ export function createCortex(config: CortexConfig) {
                     loadSessionData: agentDef.loadSessionData,
                     onToolCall: agentDef.onToolCall,
                     onStreamFinish: agentDef.onStreamFinish,
+                    context: resolvedContext,
                 };
 
                 c.set("agentConfig", resolvedConfig);
@@ -99,6 +108,7 @@ export function createCortex(config: CortexConfig) {
             agentApp.route("/", createThreadRoutes());
             agentApp.route("/", createChatRoutes());
             agentApp.route("/", createFileRoutes());
+            agentApp.route("/", createWsRoute({ useAgentParam: true }));
 
             app.route("/agents/:agentId", agentApp);
 

package/src/index.ts

@@ -7,6 +7,8 @@ export type {
     StorageConfig,
 } from "./config";
 
+export type { ContextConfig, ThreadContextMeta } from "./ai/context/types";
+
 // Types consumers may need
 export type { Thread, AppEnv } from "./types";
 

package/src/routes/chat.ts

@@ -5,6 +5,9 @@ import { HTTPException } from "hono/http-exception";
 import type { CortexAppEnv } from "../types.ts";
 import { requireAuth } from "../auth/middleware.ts";
 import { stream } from "../ai/index.ts";
+import { subscribe, abortStream } from "../ai/active-streams.ts";
+import { notify } from "../ws/index.ts";
+import { toThreadSummary } from "../types.ts";
 
 export function createChatRoutes() {
     const app = new Hono<CortexAppEnv>();
@@ -21,18 +24,60 @@ export function createChatRoutes() {
         ),
         async function (c) {
             const config = c.get("agentConfig");
+            const agentId = c.get("agentId");
             const { id: userId, token } = c.get("user");
             const { messages, id: threadId } = c.req.valid("json");
 
             const thread = await config.db.threads.getById(userId, threadId);
 
-            if (!thread) {
+            if (!thread || thread.agentId !== agentId) {
                 throw new HTTPException(404, { message: "Not found" });
             }
 
-            return stream(messages, thread, userId, token, config, c.req.raw.signal);
+            return stream(messages, thread, userId, token, config);
         },
     );
 
+    app.get("/chat/:chatId/stream", requireAuth, async function (c) {
+        const config = c.get("agentConfig");
+        const agentId = c.get("agentId");
+        const chatId = c.req.param("chatId");
+        const thread = await config.db.threads.getById(c.get("user").id, chatId);
+        if (!thread || thread.agentId !== agentId) {
+            throw new HTTPException(404, { message: "Not found" });
+        }
+
+        const subscriberStream = subscribe(chatId);
+        if (!subscriberStream) {
+            return c.body(null, 204);
+        }
+
+        return new Response(subscriberStream.pipeThrough(new TextEncoderStream()), {
+            headers: {
+                "Content-Type": "text/event-stream",
+                "Cache-Control": "no-cache",
+                Connection: "keep-alive",
+            },
+        });
+    });
+
+    app.post("/chat/:chatId/abort", requireAuth, async function (c) {
+        const config = c.get("agentConfig");
+        const agentId = c.get("agentId");
+        const userId = c.get("user").id;
+        const chatId = c.req.param("chatId");
+        const thread = await config.db.threads.getById(userId, chatId);
+        if (!thread || thread.agentId !== agentId) {
+            throw new HTTPException(404, { message: "Not found" });
+        }
+
+        abortStream(chatId);
+        notify(userId, agentId, {
+            type: "thread:run-finished",
+            payload: { thread: toThreadSummary(thread, false) },
+        });
+        return c.body(null, 204);
+    });
+
     return app;
 }

package/src/routes/threads.ts

@@ -4,6 +4,9 @@ import z from "zod";
 import type { CortexAppEnv } from "../types.ts";
 import { requireAuth } from "../auth/middleware.ts";
 import { generateTitle } from "../ai/index.ts";
+import { abortStream, isStreamRunning } from "../ai/active-streams.ts";
+import { notify } from "../ws/index.ts";
+import { toThreadSummary } from "../types.ts";
 
 export function createThreadRoutes() {
     const app = new Hono<CortexAppEnv>();
@@ -13,7 +16,7 @@ export function createThreadRoutes() {
         const agentId = c.get("agentId");
         const threads = await config.db.threads
             .list(c.get("user").id, agentId)
-            .then((x) => x.map((y) => ({ id: y.id, title: y.title, createdAt: y.createdAt })));
+            .then((x) => x.map((y) => toThreadSummary(y, isStreamRunning(y.id))));
         return c.json(threads);
     });
 
@@ -24,28 +27,55 @@ export function createThreadRoutes() {
         async function (c) {
             const config = c.get("agentConfig");
             const agentId = c.get("agentId");
+            const userId = c.get("user").id;
             const { prompt } = c.req.valid("json");
-            const { id, createdAt, title } = await config.db.threads.create(
-                c.get("user").id,
-                agentId,
-            );
-            generateTitle(id, prompt, c.get("user").id, config);
-            return c.json({ id, title, createdAt });
+            const thread = await config.db.threads.create(userId, agentId);
+
+            notify(userId, agentId, {
+                type: "thread:created",
+                payload: { thread: toThreadSummary(thread, false) },
+            });
+
+            generateTitle(thread.id, prompt, userId, config);
+
+            return c.json(toThreadSummary(thread, false));
         },
     );
 
     app.delete("/threads/:threadId", requireAuth, async function (c) {
         const config = c.get("agentConfig");
+        const agentId = c.get("agentId");
+        const userId = c.get("user").id;
         const threadId = c.req.param("threadId");
-        await config.db.threads.delete(c.get("user").id, threadId);
+
+        const thread = await config.db.threads.getById(userId, threadId);
+        if (!thread || thread.agentId !== agentId) {
+            return c.body(null, 404);
+        }
+
+        abortStream(threadId);
+        await config.db.threads.delete(userId, threadId);
+
+        notify(userId, agentId, {
+            type: "thread:deleted",
+            payload: { threadId },
+        });
+
         return c.body(null, 204);
     });
 
     app.get("/threads/:threadId/messages", requireAuth, async function (c) {
         const config = c.get("agentConfig");
+        const agentId = c.get("agentId");
+        const userId = c.get("user").id;
         const threadId = c.req.param("threadId");
+        const thread = await config.db.threads.getById(userId, threadId);
+        if (!thread || thread.agentId !== agentId) {
+            return c.body(null, 404);
+        }
+
         const messages = await config.db.messages
-            .list(c.get("user").id, threadId)
+            .list(userId, threadId)
             .then((x) => x.map((y) => y.content));
         return c.json(messages);
     });
@@ -56,8 +86,15 @@ export function createThreadRoutes() {
         zValidator("json", z.object({ session: z.record(z.unknown()) })),
         async function (c) {
             const config = c.get("agentConfig");
+            const agentId = c.get("agentId");
+            const userId = c.get("user").id;
             const threadId = c.req.param("threadId");
             const { session } = c.req.valid("json");
+            const thread = await config.db.threads.getById(userId, threadId);
+            if (!thread || thread.agentId !== agentId) {
+                return c.body(null, 404);
+            }
+
             await config.db.threads.updateSession(threadId, session);
             return c.body(null, 204);
         },

package/src/routes/ws.ts

@@ -3,31 +3,45 @@ import { upgradeWebSocket } from "hono/bun";
 import type { AppEnv } from "../types.ts";
 import { addConnection, removeConnection } from "../ws/index.ts";
 
-export function createWsRoute() {
+type WsRouteOptions = {
+    useAgentParam?: boolean;
+};
+
+export function createWsRoute(options?: WsRouteOptions) {
     const app = new Hono<AppEnv>();
+    const handleUpgrade = upgradeWebSocket(function (c) {
+        const userId = c.get("user")?.id;
+        const agentId =
+            options?.useAgentParam === true ? c.req.param("agentId") : c.req.query("agentId");
+
+        return {
+            onOpen(_, ws) {
+                if (userId && agentId) {
+                    addConnection(userId, agentId, ws);
+                }
+            },
+
+            onClose(_, ws) {
+                if (userId && agentId) {
+                    removeConnection(userId, agentId, ws);
+                }
+            },
+        };
+    });
+
+    app.get("/ws", function (c, next) {
+        if (!c.get("user")) {
+            return c.json({ error: "Unauthorized" }, 401);
+        }
+
+        const agentId =
+            options?.useAgentParam === true ? c.req.param("agentId") : c.req.query("agentId");
+        if (!agentId) {
+            return c.json({ error: "agentId is required" }, 400);
+        }
 
-    app.get(
-        "/ws",
-        upgradeWebSocket(function (c) {
-            const user = c.get("user");
-            const userId = user?.id;
-
-            return {
-                onOpen(_, ws) {
-                    if (userId) {
-                        addConnection(userId, ws);
-                    }
-                    ws.send("Connected!");
-                },
-
-                onClose(_, ws) {
-                    if (userId) {
-                        removeConnection(userId, ws);
-                    }
-                },
-            };
-        }),
-    );
+        return handleUpgrade(c, next) as unknown as Response;
+    });
 
     return app;
 }

package/src/types.ts

@@ -1,24 +1,38 @@
 import type { ToolUIPart, UIMessage } from "ai";
 import type { ResolvedCortexAgentConfig } from "./config";
+import type { InferSelectModel } from "drizzle-orm";
+import type { messages, threads } from "./db/schema";
 
-export type Thread = {
+export type Thread = InferSelectModel<typeof threads>;
+
+export type StoredMessage = InferSelectModel<typeof messages>;
+
+export type ThreadSummary = {
     id: string;
-    userId: string;
-    agentId: string;
-    title: string | null;
-    session: Record<string, unknown> | null;
+    title?: string;
     createdAt: Date;
     updatedAt: Date;
+    isRunning: boolean;
 };
 
-export type StoredMessage = {
-    id: string;
-    threadId: string;
-    text: string | null;
-    content: UIMessage;
-    role: "system" | "user" | "assistant" | "tool";
-    createdAt: Date;
-    updatedAt: Date;
+export type MessageMetadata = {
+    modelId: string;
+    providerMetadata: unknown;
+    isAborted?: boolean;
+    tokenUsage?: {
+        input: {
+            noCache: number;
+            cacheRead: number;
+            cacheWrite: number;
+            total: number;
+        };
+        output: {
+            reasoning: number;
+            text: number;
+            total: number;
+        };
+        total: number;
+    };
 };
 
 export type CapturedFileInput = {
@@ -48,3 +62,13 @@ export type CortexAppEnv = {
         agentId: string;
     };
 };
+
+export function toThreadSummary(thread: Thread, isRunning: boolean) {
+    return {
+        id: thread.id,
+        title: thread.title ?? undefined,
+        createdAt: thread.createdAt,
+        updatedAt: thread.updatedAt,
+        isRunning,
+    } satisfies ThreadSummary;
+}

package/src/ws/connections.ts

@@ -2,22 +2,28 @@ import type { WSContext } from "hono/ws";
 
 const connections = new Map<string, WSContext[]>();
 
-export function addConnection(userId: string, ws: WSContext) {
-    const sockets = connections.get(userId) ?? [];
+function getConnectionKey(userId: string, agentId: string) {
+    return `${userId}:${agentId}`;
+}
+
+export function addConnection(userId: string, agentId: string, ws: WSContext) {
+    const key = getConnectionKey(userId, agentId);
+    const sockets = connections.get(key) ?? [];
     sockets.push(ws);
-    connections.set(userId, sockets);
+    connections.set(key, sockets);
 }
 
-export function removeConnection(userId: string, ws: WSContext) {
-    let sockets = connections.get(userId) ?? [];
+export function removeConnection(userId: string, agentId: string, ws: WSContext) {
+    const key = getConnectionKey(userId, agentId);
+    let sockets = connections.get(key) ?? [];
     sockets = sockets.filter((x) => x !== ws);
     if (sockets.length) {
-        connections.set(userId, sockets);
+        connections.set(key, sockets);
     } else {
-        connections.delete(userId);
+        connections.delete(key);
     }
 }
 
-export function getConnections(userId: string) {
-    return connections.get(userId) ?? [];
+export function getConnections(userId: string, agentId: string) {
+    return connections.get(getConnectionKey(userId, agentId)) ?? [];
 }

package/src/ws/events.ts

@@ -1,11 +1,39 @@
+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: { threadId: string; title: string };
+    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 };
+    payload: { threadId: string; thread: ThreadSummary };
 };
 
-export type WsEvent = ThreadTitleUpdatedEvent | ThreadMessagesUpdatedEvent;
+export type WsEvent =
+    | ThreadCreatedEvent
+    | ThreadDeletedEvent
+    | ThreadTitleUpdatedEvent
+    | ThreadRunStartedEvent
+    | ThreadRunFinishedEvent
+    | ThreadMessagesUpdatedEvent;

package/src/ws/index.ts

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