@m6d/cortex-server 1.3.0 → 1.4.0

package/dist/src/adapters/database.d.ts

@@ -1,13 +1,16 @@
 import type { ToolUIPart, UIMessage } from "ai";
 import type { Thread, StoredMessage, CapturedFileInput } 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?: {

package/dist/src/ai/active-streams.d.ts

@@ -0,0 +1,14 @@
+type ActiveStream = {
+    id: string;
+    abortController: AbortController;
+    buffer: string[];
+    subscribers: Set<ReadableStreamDefaultController<string>>;
+    isComplete: boolean;
+};
+export declare function registerStream(threadId: string, abortController: AbortController): ActiveStream;
+export declare function attachSseStream(threadId: string, sseStream: ReadableStream<string>): void;
+export declare function subscribe(threadId: string): ReadableStream<string> | null;
+export declare function abortStream(threadId: string): boolean;
+export declare function isStreamRunning(threadId: string): boolean;
+export declare function removeStream(threadId: string, streamId?: string): void;
+export {};

package/dist/src/ai/active-streams.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/ai/context/builder.d.ts

@@ -0,0 +1,24 @@
+import type { UIMessage } from "ai";
+import type { DatabaseAdapter } from "../../adapters/database.ts";
+import type { MessageMetadata, Thread } from "../../types.ts";
+import type { ContextConfig } from "./types.ts";
+/**
+ * Builds a token-aware context window from stored messages.
+ *
+ * 1. Loads messages from DB with generous limit
+ * 2. Reads existing summary from thread.contextMeta
+ * 3. Compresses large tool results
+ * 4. Walks messages newest-to-oldest, accumulating token estimates
+ * 5. Stops when adding the next message would exceed the budget
+ * 6. Prepends summary as synthetic message if older messages were trimmed
+ */
+export declare function buildContextMessages(userId: string, thread: Thread, db: DatabaseAdapter, contextConfig: ContextConfig): Promise<{
+    messages: UIMessage<MessageMetadata, import("ai").UIDataTypes, import("ai").UITools>[];
+    allMessages: UIMessage<MessageMetadata, import("ai").UIDataTypes, import("ai").UITools>[];
+    summary: string | null;
+}>;
+/**
+ * Drops the oldest messages until the total estimated tokens fit within `budget`.
+ * Always keeps at least the most recent message.
+ */
+export declare function trimMessagesToFit(messages: UIMessage<MessageMetadata>[], budget: number): UIMessage<MessageMetadata, import("ai").UIDataTypes, import("ai").UITools>[];

package/dist/src/ai/context/compressor.d.ts

@@ -0,0 +1,7 @@
+import type { UIMessage } from "ai";
+import type { MessageMetadata } from "src/types.ts";
+/**
+ * Returns a new array of messages with large tool outputs truncated
+ * to `maxTokensPerResult`. Does not mutate the input messages.
+ */
+export declare function compressToolResults(messages: UIMessage<MessageMetadata>[], maxTokensPerResult: number): UIMessage<MessageMetadata, import("ai").UIDataTypes, import("ai").UITools>[];

package/dist/src/ai/context/index.d.ts

@@ -0,0 +1,15 @@
+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 } from "./compressor.ts";
+export { summarizeMessages } from "./summarizer.ts";
+export { buildContextMessages, trimMessagesToFit } from "./builder.ts";
+import type { UIMessage } from "ai";
+import type { ResolvedCortexAgentConfig } from "../../config.ts";
+import type { Thread } from "../../types.ts";
+/**
+ * Post-response context optimization.
+ * Called fire-and-forget from onFinish — summarizes older messages
+ * when token usage exceeds the configured threshold.
+ */
+export declare function optimizeThreadContext(thread: Thread, messages: UIMessage[], config: ResolvedCortexAgentConfig): Promise<void>;

package/dist/src/ai/context/summarizer.d.ts

@@ -0,0 +1,5 @@
+import type { UIMessage } from "ai";
+import type { ContextConfig } from "./types.ts";
+type SummarizationModelConfig = NonNullable<ContextConfig["summarizationModel"]>;
+export declare function summarizeMessages(messages: UIMessage[], existingSummary: string | null, modelConfig: SummarizationModelConfig): Promise<string>;
+export {};

package/dist/src/ai/context/token-estimator.d.ts

@@ -0,0 +1,20 @@
+import type { UIMessage } from "ai";
+/** Average characters per token for English text. Used by the heuristic estimator. */
+export declare const CHARS_PER_TOKEN = 4;
+/**
+ * Estimates token count for a string using the chars/4 heuristic.
+ * ~10% accuracy for English text — good enough for budget decisions.
+ */
+export declare function estimateTokens(text: string): number;
+/**
+ * Estimates token count for a single UIMessage by walking its parts.
+ */
+export declare function estimateMessageTokens(message: UIMessage): number;
+/**
+ * Estimates token counts for an array of UIMessages.
+ * Returns per-message estimates in the same order.
+ */
+export declare function estimateMessagesTokens(messages: UIMessage[]): {
+    message: UIMessage<unknown, import("ai").UIDataTypes, import("ai").UITools>;
+    tokens: number;
+}[];

package/dist/src/ai/context/types.d.ts

@@ -0,0 +1,20 @@
+export type ContextConfig = {
+    maxContextTokens: number;
+    reservedTokenBudget: number;
+    summarizationThreshold: number;
+    summarizationModel?: {
+        baseURL: string;
+        apiKey: string;
+        modelName: string;
+        providerName?: string;
+    };
+    toolResultMaxTokens: number;
+    recentMessagesToKeep: number;
+};
+export type ThreadContextMeta = {
+    summary: string | null;
+    summaryUpToMessageId: string | null;
+    totalEstimatedTokens: number;
+    lastOptimizedAt: string | null;
+};
+export declare const DEFAULT_CONTEXT_CONFIG: ContextConfig;

package/dist/src/ai/index.d.ts

@@ -1,4 +1,4 @@
 import type { ResolvedCortexAgentConfig } from "../config.ts";
 import type { Thread } from "../types.ts";
-export declare function stream(messages: unknown[], thread: Thread, userId: string, token: string, config: ResolvedCortexAgentConfig, abortSignal?: AbortSignal): Promise<Response>;
+export declare function stream(messages: unknown[], thread: Thread, userId: string, token: string, config: ResolvedCortexAgentConfig): Promise<Response>;
 export declare function generateTitle(threadId: string, prompt: string, userId: string, config: ResolvedCortexAgentConfig): Promise<void>;

package/dist/src/ai/prompt.d.ts

@@ -1,4 +1,9 @@
 import type { ResolvedContext } from "../graph/resolver.ts";
 import type { ResolvedCortexAgentConfig } from "../config.ts";
 import type { Thread } from "../types.ts";
-export declare function buildSystemPrompt(config: ResolvedCortexAgentConfig, prompt: string, thread: Thread, token: string, resolved: ResolvedContext | null): Promise<string>;
+/**
+ * Resolves session data for the thread, loading from the configured
+ * session loader if not already cached on the thread.
+ */
+export declare function resolveSession(config: ResolvedCortexAgentConfig, thread: Thread, token: string): Promise<Record<string, unknown> | null>;
+export declare function buildSystemPrompt(config: ResolvedCortexAgentConfig, resolved: ResolvedContext | null, session: Record<string, unknown> | null): Promise<string>;

package/dist/src/config.d.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;
 };
 export type ResolvedCortexAgentConfig = {
@@ -111,6 +113,7 @@ export type ResolvedCortexAgentConfig = {
         messages: UIMessage[];
         isAborted: boolean;
     }) => void;
+    context: ContextConfig;
     knowledge?: KnowledgeConfig;
 };
 export type CortexConfig = {
@@ -144,6 +147,7 @@ export type CortexConfig = {
         url: string;
         apiKey: string;
     };
+    context?: Partial<ContextConfig>;
     knowledge?: KnowledgeConfig;
     agents: Record<string, CortexAgentDefinition>;
 };

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

@@ -1,4 +1,6 @@
 import type { UIMessage } from "ai";
+import type { MessageMetadata } from "src/types";
+import type { ThreadContextMeta } from "../ai/context/types.ts";
 export declare const aiSchema: import("drizzle-orm/mssql-core").MsSqlSchema<"ai">;
 export declare const threads: import("drizzle-orm/mssql-core").MsSqlTableWithColumns<{
     name: "threads";
@@ -116,6 +118,22 @@ export declare const threads: import("drizzle-orm/mssql-core").MsSqlTableWithCol
             identity: undefined;
             generated: undefined;
         }, {}>;
+        contextMeta: import("drizzle-orm/mssql-core").MsSqlColumn<{
+            name: string;
+            tableName: "threads";
+            dataType: "object json";
+            data: ThreadContextMeta;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}>;
     };
     dialect: "mssql";
 }>;
@@ -207,7 +225,7 @@ export declare const messages: import("drizzle-orm/mssql-core").MsSqlTableWithCo
             name: string;
             tableName: "messages";
             dataType: "object json";
-            data: UIMessage<unknown, import("ai").UIDataTypes, import("ai").UITools>;
+            data: UIMessage<MessageMetadata, import("ai").UIDataTypes, import("ai").UITools>;
             driverParam: string;
             notNull: true;
             hasDefault: false;

package/dist/src/index.d.ts

@@ -1,4 +1,5 @@
 export type { CortexConfig, CortexAgentDefinition, KnowledgeConfig, DatabaseConfig, StorageConfig, } from "./config";
+export type { ContextConfig, ThreadContextMeta } from "./ai/context/types";
 export type { Thread, AppEnv } from "./types";
 export type { CortexInstance } from "./factory";
 export { createCortex } from "./factory";

package/dist/src/routes/ws.d.ts

@@ -1,3 +1,7 @@
 import { Hono } from "hono";
 import type { AppEnv } from "../types.ts";
-export declare function createWsRoute(): Hono<AppEnv, import("hono/types").BlankSchema, "/">;
+type WsRouteOptions = {
+    useAgentParam?: boolean;
+};
+export declare function createWsRoute(options?: WsRouteOptions): Hono<AppEnv, import("hono/types").BlankSchema, "/">;
+export {};

package/dist/src/types.d.ts

@@ -1,22 +1,33 @@
-import type { UIMessage } from "ai";
 import type { ResolvedCortexAgentConfig } from "./config";
-export type Thread = {
+import type { InferSelectModel } from "drizzle-orm";
+import type { messages, threads } from "./db/schema";
+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 = {
     id: string;
@@ -54,3 +65,10 @@ export type CortexAppEnv = {
         agentId: string;
     };
 };
+export declare function toThreadSummary(thread: Thread, isRunning: boolean): {
+    id: string;
+    title: string | undefined;
+    createdAt: Date;
+    updatedAt: Date;
+    isRunning: boolean;
+};

package/dist/src/ws/connections.d.ts

@@ -1,4 +1,4 @@
 import type { WSContext } from "hono/ws";
-export declare function addConnection(userId: string, ws: WSContext): void;
-export declare function removeConnection(userId: string, ws: WSContext): void;
-export declare function getConnections(userId: string): WSContext<unknown>[];
+export declare function addConnection(userId: string, agentId: string, ws: WSContext): void;
+export declare function removeConnection(userId: string, agentId: string, ws: WSContext): void;
+export declare function getConnections(userId: string, agentId: string): WSContext<unknown>[];

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

@@ -1,14 +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;
+        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 = ThreadTitleUpdatedEvent | ThreadMessagesUpdatedEvent;
+export type WsEvent = ThreadCreatedEvent | ThreadDeletedEvent | ThreadTitleUpdatedEvent | ThreadRunStartedEvent | ThreadRunFinishedEvent | ThreadMessagesUpdatedEvent;

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

@@ -1,3 +1,3 @@
 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";

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

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

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@m6d/cortex-server",
-    "version": "1.3.0",
+    "version": "1.4.0",
     "description": "Reusable AI agent chat server library for Hono + Bun",
     "license": "MIT",
     "type": "module",

package/src/adapters/database.ts

@@ -1,5 +1,6 @@
 import type { ToolUIPart, UIMessage } from "ai";
 import type { Thread, StoredMessage, CapturedFileInput } from "../types";
+import type { ThreadContextMeta } from "../ai/context/types.ts";
 
 export type DatabaseAdapter = {
     threads: {
@@ -7,8 +8,10 @@ export type DatabaseAdapter = {
         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[]>;

package/src/adapters/mssql.ts

@@ -4,7 +4,8 @@ import { drizzle } from "drizzle-orm/node-mssql";
 import { threads, messages, capturedFiles } from "../db/schema";
 import type { DatabaseAdapter } from "./database";
 import type { StorageAdapter } from "./storage";
-import type { Thread, CapturedFileInput } from "../types";
+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" });
@@ -16,7 +17,7 @@ export function createMssqlAdapter(connectionString: string, storage: StorageAda
                     .select()
                     .from(threads)
                     .where(and(eq(threads.userId, userId), eq(threads.agentId, agentId)))
-                    .orderBy(desc(threads.createdAt))) as Thread[];
+                    .orderBy(desc(threads.updatedAt), desc(threads.createdAt))) as Thread[];
             },
 
             async getById(userId: string, threadId: string) {
@@ -56,6 +57,17 @@ export function createMssqlAdapter(connectionString: string, storage: StorageAda
                     .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();
             },
@@ -63,6 +75,14 @@ export function createMssqlAdapter(connectionString: string, storage: StorageAda
             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: {
@@ -78,8 +98,8 @@ export function createMssqlAdapter(connectionString: string, storage: StorageAda
                     .then((x) => x.reverse());
             },
 
-            async upsert(threadId: string, messagesToInsert: UIMessage[]) {
-                const ids = messagesToInsert.map((x) => x.id);
+            async upsert(threadId: string, messagesToUpsert: UIMessage<MessageMetadata>[]) {
+                const ids = messagesToUpsert.map((x) => x.id);
 
                 const existingIds = await db
                     .select({ id: messages.id })
@@ -88,7 +108,7 @@ export function createMssqlAdapter(connectionString: string, storage: StorageAda
                     .execute()
                     .then((x) => x.map((y) => y.id));
 
-                const newMessages = messagesToInsert.filter((x) => !existingIds.includes(x.id));
+                const newMessages = messagesToUpsert.filter((x) => !existingIds.includes(x.id));
 
                 if (newMessages.length) {
                     await db
@@ -108,7 +128,7 @@ export function createMssqlAdapter(connectionString: string, storage: StorageAda
                         .execute();
                 }
 
-                const existingMessages = messagesToInsert.filter((x) => existingIds.includes(x.id));
+                const existingMessages = messagesToUpsert.filter((x) => existingIds.includes(x.id));
                 for (const message of existingMessages) {
                     await db
                         .update(messages)

package/src/ai/active-streams.test.ts

@@ -0,0 +1,21 @@
+import { afterEach, describe, expect, it } from "bun:test";
+import { registerStream, removeStream, subscribe } from "./active-streams.ts";
+
+describe("active-streams", function () {
+    afterEach(function () {
+        removeStream("thread-under-test");
+    });
+
+    it("does not remove a newer stream when cleaning up an older one", function () {
+        const firstStream = registerStream("thread-under-test", new AbortController());
+        const secondStream = registerStream("thread-under-test", new AbortController());
+
+        removeStream("thread-under-test", firstStream.id);
+
+        expect(subscribe("thread-under-test")).not.toBeNull();
+
+        removeStream("thread-under-test", secondStream.id);
+
+        expect(subscribe("thread-under-test")).toBeNull();
+    });
+});

package/src/ai/active-streams.ts

@@ -0,0 +1,123 @@
+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);
+}