@langchain/langgraph-api 0.0.19 → 0.0.21

package/dist/storage/ops.mjs

@@ -7,6 +7,7 @@ import { logger } from "../logging.mjs";
 import { serializeError } from "../utils/serde.mjs";
 import { FileSystemPersistence } from "./persist.mjs";
 import { getLangGraphCommand } from "../command.mjs";
+import { handleAuthEvent, isAuthMatching } from "../auth/custom.mjs";
 export const conn = new FileSystemPersistence(".langgraphjs_ops.json", () => ({
     runs: {},
     threads: {},
@@ -129,7 +130,13 @@ const isJsonbContained = (superset, subset) => {
     return true;
 };
 export class Assistants {
-    static async *search(options) {
+    static async *search(options, auth) {
+        const [filters] = await handleAuthEvent(auth, "assistants:search", {
+            graph_id: options.graph_id,
+            metadata: options.metadata,
+            limit: options.limit,
+            offset: options.offset,
+        });
         yield* conn.withGenerator(async function* (STORE) {
             let filtered = Object.values(STORE.assistants)
                 .filter((assistant) => {
@@ -141,6 +148,9 @@ export class Assistants {
                     !isJsonbContained(assistant["metadata"], options.metadata)) {
                     return false;
                 }
+                if (!isAuthMatching(assistant["metadata"], filters)) {
+                    return false;
+                }
                 return true;
             })
                 .sort((a, b) => {
@@ -153,55 +163,84 @@ export class Assistants {
             }
         });
     }
-    static async get(assistantId) {
+    static async get(assistant_id, auth) {
+        const [filters] = await handleAuthEvent(auth, "assistants:read", {
+            assistant_id,
+        });
         return conn.with((STORE) => {
-            const result = STORE.assistants[assistantId];
+            const result = STORE.assistants[assistant_id];
             if (result == null)
                 throw new HTTPException(404, { message: "Assistant not found" });
+            if (!isAuthMatching(result["metadata"], filters)) {
+                throw new HTTPException(404, { message: "Assistant not found" });
+            }
             return { ...result, name: result.name ?? result.graph_id };
         });
     }
-    static async put(assistantId, options) {
+    static async put(assistant_id, options, auth) {
+        const [filters, mutable] = await handleAuthEvent(auth, "assistants:create", {
+            assistant_id,
+            config: options.config,
+            graph_id: options.graph_id,
+            metadata: options.metadata,
+            if_exists: options.if_exists,
+            name: options.name,
+        });
         return conn.with((STORE) => {
-            if (STORE.assistants[assistantId] != null) {
+            if (STORE.assistants[assistant_id] != null) {
+                const existingAssistant = STORE.assistants[assistant_id];
+                if (!isAuthMatching(existingAssistant?.metadata, filters)) {
+                    throw new HTTPException(409, { message: "Assistant already exists" });
+                }
                 if (options.if_exists === "raise") {
                     throw new HTTPException(409, { message: "Assistant already exists" });
                 }
-                return STORE.assistants[assistantId];
+                return existingAssistant;
             }
             const now = new Date();
-            STORE.assistants[assistantId] ??= {
-                assistant_id: assistantId,
+            STORE.assistants[assistant_id] ??= {
+                assistant_id: assistant_id,
                 version: 1,
                 config: options.config ?? {},
                 created_at: now,
                 updated_at: now,
                 graph_id: options.graph_id,
-                metadata: options.metadata ?? {},
+                metadata: mutable.metadata ?? {},
                 name: options.name || options.graph_id,
             };
             STORE.assistant_versions.push({
-                assistant_id: assistantId,
+                assistant_id: assistant_id,
                 version: 1,
                 graph_id: options.graph_id,
                 config: options.config ?? {},
-                metadata: options.metadata ?? {},
+                metadata: mutable.metadata ?? {},
                 created_at: now,
                 name: options.name || options.graph_id,
             });
-            return STORE.assistants[assistantId];
+            return STORE.assistants[assistant_id];
         });
     }
-    static async patch(assistantId, options) {
+    static async patch(assistantId, options, auth) {
+        const [filters, mutable] = await handleAuthEvent(auth, "assistants:update", {
+            assistant_id: assistantId,
+            graph_id: options?.graph_id,
+            config: options?.config,
+            metadata: options?.metadata,
+            name: options?.name,
+        });
         return conn.with((STORE) => {
             const assistant = STORE.assistants[assistantId];
-            if (!assistant)
+            if (!assistant) {
                 throw new HTTPException(404, { message: "Assistant not found" });
+            }
+            if (!isAuthMatching(assistant["metadata"], filters)) {
+                throw new HTTPException(404, { message: "Assistant not found" });
+            }
             const now = new Date();
-            const metadata = options?.metadata != null
+            const metadata = mutable.metadata != null
                 ? {
                     ...assistant["metadata"],
-                    ...options.metadata,
+                    ...mutable.metadata,
                 }
                 : null;
             if (options?.graph_id != null) {
@@ -234,34 +273,49 @@ export class Assistants {
             return assistant;
         });
     }
-    static async delete(assistantId) {
+    static async delete(assistant_id, auth) {
+        const [filters] = await handleAuthEvent(auth, "assistants:delete", {
+            assistant_id,
+        });
         return conn.with((STORE) => {
-            const assistant = STORE.assistants[assistantId];
-            if (!assistant)
+            const assistant = STORE.assistants[assistant_id];
+            if (!assistant) {
+                throw new HTTPException(404, { message: "Assistant not found" });
+            }
+            if (!isAuthMatching(assistant["metadata"], filters)) {
                 throw new HTTPException(404, { message: "Assistant not found" });
-            delete STORE.assistants[assistantId];
+            }
+            delete STORE.assistants[assistant_id];
             // Cascade delete for assistant versions and crons
-            STORE.assistant_versions = STORE.assistant_versions.filter((v) => v["assistant_id"] !== assistantId);
+            STORE.assistant_versions = STORE.assistant_versions.filter((v) => v["assistant_id"] !== assistant_id);
             for (const run of Object.values(STORE.runs)) {
-                if (run["assistant_id"] === assistantId) {
+                if (run["assistant_id"] === assistant_id) {
                     delete STORE.runs[run["run_id"]];
                 }
             }
             return [assistant.assistant_id];
         });
     }
-    static async setLatest(assistantId, version) {
+    static async setLatest(assistant_id, version, auth) {
+        const [filters] = await handleAuthEvent(auth, "assistants:update", {
+            assistant_id,
+            version,
+        });
         return conn.with((STORE) => {
-            const assistant = STORE.assistants[assistantId];
-            if (!assistant)
+            const assistant = STORE.assistants[assistant_id];
+            if (!assistant) {
+                throw new HTTPException(404, { message: "Assistant not found" });
+            }
+            if (!isAuthMatching(assistant["metadata"], filters)) {
                 throw new HTTPException(404, { message: "Assistant not found" });
-            const assistantVersion = STORE.assistant_versions.find((v) => v["assistant_id"] === assistantId && v["version"] === version);
+            }
+            const assistantVersion = STORE.assistant_versions.find((v) => v["assistant_id"] === assistant_id && v["version"] === version);
             if (!assistantVersion)
                 throw new HTTPException(404, {
                     message: "Assistant version not found",
                 });
             const now = new Date();
-            STORE.assistants[assistantId] = {
+            STORE.assistants[assistant_id] = {
                 ...assistant,
                 config: assistantVersion["config"],
                 metadata: assistantVersion["metadata"],
@@ -269,19 +323,25 @@ export class Assistants {
                 name: assistantVersion["name"],
                 updated_at: now,
             };
-            return STORE.assistants[assistantId];
+            return STORE.assistants[assistant_id];
         });
     }
-    static async getVersions(assistantId, options) {
+    static async getVersions(assistant_id, options, auth) {
+        const [filters] = await handleAuthEvent(auth, "assistants:read", {
+            assistant_id,
+        });
         return conn.with((STORE) => {
             const versions = STORE.assistant_versions
                 .filter((version) => {
-                if (version["assistant_id"] !== assistantId)
+                if (version["assistant_id"] !== assistant_id)
                     return false;
                 if (options.metadata != null &&
                     !isJsonbContained(version["metadata"], options.metadata)) {
                     return false;
                 }
+                if (!isAuthMatching(version["metadata"], filters)) {
+                    return false;
+                }
                 return true;
             })
                 .sort((a, b) => b["version"] - a["version"]);
@@ -290,7 +350,14 @@ export class Assistants {
     }
 }
 export class Threads {
-    static async *search(options) {
+    static async *search(options, auth) {
+        const [filters] = await handleAuthEvent(auth, "threads:search", {
+            metadata: options.metadata,
+            status: options.status,
+            values: options.values,
+            limit: options.limit,
+            offset: options.offset,
+        });
         yield* conn.withGenerator(async function* (STORE) {
             const filtered = Object.values(STORE.threads)
                 .filter((thread) => {
@@ -303,6 +370,8 @@ export class Threads {
                     return false;
                 if (options.status != null && thread["status"] !== options.status)
                     return false;
+                if (!isAuthMatching(thread["metadata"], filters))
+                    return false;
                 return true;
             })
                 .sort((a, b) => b["created_at"].getTime() - a["created_at"].getTime());
@@ -311,47 +380,75 @@ export class Threads {
             }
         });
     }
-    static async get(threadId) {
+    // TODO: make this accept `undefined`
+    static async get(thread_id, auth) {
+        const [filters] = await handleAuthEvent(auth, "threads:read", {
+            thread_id,
+        });
         return conn.with((STORE) => {
-            const result = STORE.threads[threadId];
-            if (result == null)
+            const result = STORE.threads[thread_id];
+            if (result == null) {
+                throw new HTTPException(404, {
+                    message: `Thread with ID ${thread_id} not found`,
+                });
+            }
+            if (!isAuthMatching(result["metadata"], filters)) {
                 throw new HTTPException(404, {
-                    message: `Thread with ID ${threadId} not found`,
+                    message: `Thread with ID ${thread_id} not found`,
                 });
+            }
             return result;
         });
     }
-    static async put(threadId, options) {
+    static async put(thread_id, options, auth) {
+        const [filters, mutable] = await handleAuthEvent(auth, "threads:create", {
+            thread_id,
+            metadata: options.metadata,
+            if_exists: options.if_exists,
+        });
         return conn.with((STORE) => {
             const now = new Date();
-            if (STORE.threads[threadId] != null) {
+            if (STORE.threads[thread_id] != null) {
+                const existingThread = STORE.threads[thread_id];
+                if (!isAuthMatching(existingThread["metadata"], filters)) {
+                    throw new HTTPException(409, { message: "Thread already exists" });
+                }
                 if (options?.if_exists === "raise") {
                     throw new HTTPException(409, { message: "Thread already exists" });
                 }
-                return STORE.threads[threadId];
+                return existingThread;
             }
-            STORE.threads[threadId] ??= {
-                thread_id: threadId,
+            STORE.threads[thread_id] ??= {
+                thread_id: thread_id,
                 created_at: now,
                 updated_at: now,
-                metadata: options?.metadata ?? {},
+                metadata: mutable?.metadata ?? {},
                 status: "idle",
                 config: {},
                 values: undefined,
             };
-            return STORE.threads[threadId];
+            return STORE.threads[thread_id];
         });
     }
-    static async patch(threadId, options) {
+    static async patch(threadId, options, auth) {
+        const [filters, mutable] = await handleAuthEvent(auth, "threads:update", {
+            thread_id: threadId,
+            metadata: options.metadata,
+        });
         return conn.with((STORE) => {
             const thread = STORE.threads[threadId];
-            if (!thread)
+            if (!thread) {
+                throw new HTTPException(404, { message: "Thread not found" });
+            }
+            if (!isAuthMatching(thread["metadata"], filters)) {
+                // TODO: is this correct status code?
                 throw new HTTPException(404, { message: "Thread not found" });
+            }
             const now = new Date();
-            if (options?.metadata != null) {
+            if (mutable.metadata != null) {
                 thread["metadata"] = {
                     ...thread["metadata"],
-                    ...options.metadata,
+                    ...mutable.metadata,
                 };
             }
             thread["updated_at"] = now;
@@ -393,28 +490,43 @@ export class Threads {
                     : undefined;
         });
     }
-    static async delete(threadId) {
+    static async delete(thread_id, auth) {
+        const [filters] = await handleAuthEvent(auth, "threads:delete", {
+            thread_id,
+        });
         return conn.with((STORE) => {
-            const thread = STORE.threads[threadId];
-            if (!thread)
+            const thread = STORE.threads[thread_id];
+            if (!thread) {
+                throw new HTTPException(404, {
+                    message: `Thread with ID ${thread_id} not found`,
+                });
+            }
+            if (!isAuthMatching(thread["metadata"], filters)) {
                 throw new HTTPException(404, {
-                    message: `Thread with ID ${threadId} not found`,
+                    message: `Thread with ID ${thread_id} not found`,
                 });
-            delete STORE.threads[threadId];
+            }
+            delete STORE.threads[thread_id];
             for (const run of Object.values(STORE.runs)) {
-                if (run["thread_id"] === threadId) {
+                if (run["thread_id"] === thread_id) {
                     delete STORE.runs[run["run_id"]];
                 }
             }
-            checkpointer.delete(threadId, null);
+            checkpointer.delete(thread_id, null);
             return [thread.thread_id];
         });
     }
-    static async copy(threadId) {
+    static async copy(thread_id, auth) {
+        const [filters] = await handleAuthEvent(auth, "threads:read", {
+            thread_id,
+        });
         return conn.with((STORE) => {
-            const thread = STORE.threads[threadId];
+            const thread = STORE.threads[thread_id];
             if (!thread)
                 throw new HTTPException(409, { message: "Thread not found" });
+            if (!isAuthMatching(thread["metadata"], filters)) {
+                throw new HTTPException(409, { message: "Thread not found" });
+            }
             const newThreadId = uuid4();
             const now = new Date();
             STORE.threads[newThreadId] = {
@@ -425,15 +537,15 @@ export class Threads {
                 config: {},
                 status: "idle",
             };
-            checkpointer.copy(threadId, newThreadId);
+            checkpointer.copy(thread_id, newThreadId);
             return STORE.threads[newThreadId];
         });
     }
     static State = class {
-        static async get(config, options) {
+        static async get(config, options, auth) {
             const subgraphs = options.subgraphs ?? false;
             const threadId = config.configurable?.thread_id;
-            const thread = threadId ? await Threads.get(threadId) : undefined;
+            const thread = threadId ? await Threads.get(threadId, auth) : undefined;
             const metadata = thread?.metadata ?? {};
             const graphId = metadata?.graph_id;
             if (!thread || graphId == null) {
@@ -459,13 +571,19 @@ export class Threads {
             }
             return result;
         }
-        static async post(config, values, asNode) {
+        static async post(config, values, asNode, auth) {
             const threadId = config.configurable?.thread_id;
-            const thread = threadId ? await Threads.get(threadId) : undefined;
+            const [filters] = await handleAuthEvent(auth, "threads:update", {
+                thread_id: threadId,
+            });
+            const thread = threadId ? await Threads.get(threadId, auth) : undefined;
             if (!thread)
                 throw new HTTPException(404, {
                     message: `Thread ${threadId} not found`,
                 });
+            if (!isAuthMatching(thread["metadata"], filters)) {
+                throw new HTTPException(403);
+            }
             const graphId = thread.metadata?.graph_id;
             if (graphId == null) {
                 throw new HTTPException(400, {
@@ -482,7 +600,7 @@ export class Threads {
             updateConfig.configurable ??= {};
             updateConfig.configurable.checkpoint_ns ??= "";
             const nextConfig = await graph.updateState(updateConfig, values, asNode);
-            const state = await Threads.State.get(config, { subgraphs: false });
+            const state = await Threads.State.get(config, { subgraphs: false }, auth);
             // update thread values
             await conn.with(async (STORE) => {
                 for (const thread of Object.values(STORE.threads)) {
@@ -494,11 +612,17 @@ export class Threads {
             });
             return { checkpoint: nextConfig.configurable };
         }
-        static async bulk(config, supersteps) {
+        static async bulk(config, supersteps, auth) {
             const threadId = config.configurable?.thread_id;
             if (!threadId)
                 return [];
-            const thread = await Threads.get(threadId);
+            const [filters] = await handleAuthEvent(auth, "threads:update", {
+                thread_id: threadId,
+            });
+            const thread = await Threads.get(threadId, auth);
+            if (!isAuthMatching(thread["metadata"], filters)) {
+                throw new HTTPException(403);
+            }
             const graphId = thread.metadata?.graph_id;
             if (graphId == null) {
                 throw new HTTPException(400, {
@@ -520,7 +644,7 @@ export class Threads {
                     asNode: j.as_node,
                 })),
             })));
-            const state = await Threads.State.get(config, { subgraphs: false });
+            const state = await Threads.State.get(config, { subgraphs: false }, auth);
             // update thread values
             await conn.with(async (STORE) => {
                 for (const thread of Object.values(STORE.threads)) {
@@ -532,11 +656,16 @@ export class Threads {
             });
             return { checkpoint: nextConfig.configurable };
         }
-        static async list(config, options) {
+        static async list(config, options, auth) {
             const threadId = config.configurable?.thread_id;
             if (!threadId)
                 return [];
-            const thread = await Threads.get(threadId);
+            const [filters] = await handleAuthEvent(auth, "threads:read", {
+                thread_id: threadId,
+            });
+            const thread = await Threads.get(threadId, auth);
+            if (!isAuthMatching(thread["metadata"], filters))
+                return [];
             const graphId = thread.metadata?.graph_id;
             if (graphId == null)
                 return [];
@@ -592,7 +721,7 @@ export class Runs {
             }
         });
     }
-    static async put(runId, assistantId, kwargs, options) {
+    static async put(runId, assistantId, kwargs, options, auth) {
         return conn.with(async (STORE) => {
             const assistant = STORE.assistants[assistantId];
             if (!assistant) {
@@ -605,16 +734,36 @@ export class Runs {
             const afterSeconds = options?.afterSeconds ?? 0;
             const status = options?.status ?? "pending";
             let threadId = options?.threadId;
-            const metadata = options?.metadata ?? {};
+            const [filters, mutable] = await handleAuthEvent(auth, "threads:create_run", {
+                thread_id: threadId,
+                assistant_id: assistantId,
+                run_id: runId,
+                status: status,
+                metadata: options?.metadata ?? {},
+                prevent_insert_if_inflight: options?.preventInsertInInflight,
+                multitask_strategy: multitaskStrategy,
+                if_not_exists: ifNotExists,
+                after_seconds: afterSeconds,
+                kwargs,
+            });
+            const metadata = mutable.metadata ?? {};
             const config = kwargs.config ?? {};
             const existingThread = Object.values(STORE.threads).find((thread) => thread.thread_id === threadId);
+            if (existingThread &&
+                !isAuthMatching(existingThread["metadata"], filters)) {
+                throw new HTTPException(404);
+            }
             const now = new Date();
             if (!existingThread && (threadId == null || ifNotExists === "create")) {
                 threadId ??= uuid4();
                 const thread = {
                     thread_id: threadId,
                     status: "busy",
-                    metadata: { graph_id: assistant.graph_id, assistant_id: assistantId },
+                    metadata: {
+                        graph_id: assistant.graph_id,
+                        assistant_id: assistantId,
+                        ...metadata,
+                    },
                     config: Object.assign({}, assistant.config, config, {
                         configurable: Object.assign({}, assistant.config?.configurable, config?.configurable),
                     }),
@@ -675,29 +824,47 @@ export class Runs {
             return [newRun, ...inflightRuns];
         });
     }
-    static async get(runId, threadId) {
+    static async get(runId, thread_id, auth) {
+        const [filters] = await handleAuthEvent(auth, "threads:read", {
+            thread_id,
+        });
         return conn.with(async (STORE) => {
             const run = STORE.runs[runId];
             if (!run ||
                 run.run_id !== runId ||
-                (threadId != null && run.thread_id !== threadId))
+                (thread_id != null && run.thread_id !== thread_id))
                 return null;
+            if (filters != null) {
+                const thread = STORE.threads[run.thread_id];
+                if (!isAuthMatching(thread["metadata"], filters))
+                    return null;
+            }
             return run;
         });
     }
-    static async delete(runId, threadId) {
+    static async delete(run_id, thread_id, auth) {
+        const [filters] = await handleAuthEvent(auth, "threads:delete", {
+            run_id,
+            thread_id,
+        });
         return conn.with(async (STORE) => {
-            const run = STORE.runs[runId];
-            if (!run || (threadId != null && run.thread_id !== threadId))
-                throw new Error("Run not found");
-            if (threadId != null)
-                checkpointer.delete(threadId, runId);
-            delete STORE.runs[runId];
+            const run = STORE.runs[run_id];
+            if (!run || (thread_id != null && run.thread_id !== thread_id))
+                throw new HTTPException(404, { message: "Run not found" });
+            if (filters != null) {
+                const thread = STORE.threads[run.thread_id];
+                if (!isAuthMatching(thread["metadata"], filters)) {
+                    throw new HTTPException(404, { message: "Run not found" });
+                }
+            }
+            if (thread_id != null)
+                checkpointer.delete(thread_id, run_id);
+            delete STORE.runs[run_id];
             return run.run_id;
         });
     }
-    static async wait(runId, threadId) {
-        const runStream = Runs.Stream.join(runId, threadId);
+    static async wait(runId, threadId, auth) {
+        const runStream = Runs.Stream.join(runId, threadId, { ignore404: threadId == null }, auth);
         const lastChunk = new Promise(async (resolve, reject) => {
             try {
                 let lastChunk = null;
@@ -717,24 +884,34 @@ export class Runs {
         });
         return lastChunk;
     }
-    static async join(runId, threadId) {
+    static async join(runId, threadId, auth) {
         // check if thread exists
-        await Threads.get(threadId);
-        const lastChunk = await Runs.wait(runId, threadId);
+        await Threads.get(threadId, auth);
+        const lastChunk = await Runs.wait(runId, threadId, auth);
         if (lastChunk != null)
             return lastChunk;
-        const thread = await Threads.get(threadId);
+        const thread = await Threads.get(threadId, auth);
         return thread.values;
     }
-    static async cancel(threadId, runIds, options) {
+    static async cancel(threadId, runIds, options, auth) {
         return conn.with(async (STORE) => {
             const action = options.action ?? "interrupt";
             const promises = [];
+            const [filters] = await handleAuthEvent(auth, "threads:update", {
+                thread_id: threadId,
+                action,
+                metadata: { run_ids: runIds, status: "pending" },
+            });
             let foundRunsCount = 0;
             for (const runId of runIds) {
                 const run = STORE.runs[runId];
                 if (!run || (threadId != null && run.thread_id !== threadId))
                     continue;
+                if (filters != null) {
+                    const thread = STORE.threads[run.thread_id];
+                    if (!isAuthMatching(thread["metadata"], filters))
+                        continue;
+                }
                 foundRunsCount += 1;
                 // send cancellation message
                 const control = StreamManager.getControl(runId);
@@ -749,7 +926,7 @@ export class Runs {
                             run_id: runId,
                             thread_id: threadId,
                         });
-                        promises.push(Runs.delete(runId, threadId));
+                        promises.push(Runs.delete(runId, threadId, auth));
                     }
                 }
                 else {
@@ -772,7 +949,12 @@ export class Runs {
             }
         });
     }
-    static async search(threadId, options) {
+    static async search(threadId, options, auth) {
+        const [filters] = await handleAuthEvent(auth, "threads:search", {
+            thread_id: threadId,
+            metadata: options.metadata,
+            status: options.status,
+        });
         return conn.with(async (STORE) => {
             const runs = Object.values(STORE.runs).filter((run) => {
                 if (run.thread_id !== threadId)
@@ -782,6 +964,11 @@ export class Runs {
                 if (options?.metadata != null &&
                     !isJsonbContained(run.metadata, options.metadata))
                     return false;
+                if (filters != null) {
+                    const thread = STORE.threads[run.thread_id];
+                    if (!isAuthMatching(thread["metadata"], filters))
+                        return false;
+                }
                 return true;
             });
             return runs.slice(options?.offset ?? 0, options?.limit ?? 10);
@@ -797,39 +984,55 @@ export class Runs {
         });
     }
     static Stream = class {
-        static async *join(runId, threadId, options) {
-            // TODO: what if we're joining an already completed run? Should we check before?
-            const signal = options?.cancelOnDisconnect;
-            const queue = StreamManager.getQueue(runId, { ifNotFound: "create" });
-            while (!signal?.aborted) {
-                try {
-                    const message = await queue.get({ timeout: 500, signal });
-                    if (message.topic === `run:${runId}:control`) {
-                        if (message.data === "done")
-                            break;
-                    }
-                    else {
-                        const streamTopic = message.topic.substring(`run:${runId}:stream:`.length);
-                        yield { event: streamTopic, data: message.data };
+        static async *join(runId, threadId, options, auth) {
+            yield* conn.withGenerator(async function* (STORE) {
+                // TODO: what if we're joining an already completed run? Should we check before?
+                const signal = options?.cancelOnDisconnect;
+                const queue = StreamManager.getQueue(runId, { ifNotFound: "create" });
+                const [filters] = await handleAuthEvent(auth, "threads:read", {
+                    thread_id: threadId,
+                });
+                // TODO: consolidate into a single function
+                if (filters != null && threadId != null) {
+                    const thread = STORE.threads[threadId];
+                    if (!isAuthMatching(thread["metadata"], filters)) {
+                        yield {
+                            event: "error",
+                            data: { error: "Error", message: "404: Thread not found" },
+                        };
+                        return;
                     }
                 }
-                catch (error) {
-                    if (error instanceof AbortError)
-                        break;
-                    const run = await Runs.get(runId, threadId);
-                    if (run == null) {
-                        if (!options?.ignore404)
-                            yield { event: "error", data: "Run not found" };
-                        break;
+                while (!signal?.aborted) {
+                    try {
+                        const message = await queue.get({ timeout: 500, signal });
+                        if (message.topic === `run:${runId}:control`) {
+                            if (message.data === "done")
+                                break;
+                        }
+                        else {
+                            const streamTopic = message.topic.substring(`run:${runId}:stream:`.length);
+                            yield { event: streamTopic, data: message.data };
+                        }
                     }
-                    else if (run.status !== "pending") {
-                        break;
+                    catch (error) {
+                        if (error instanceof AbortError)
+                            break;
+                        const run = await Runs.get(runId, threadId, auth);
+                        if (run == null) {
+                            if (!options?.ignore404)
+                                yield { event: "error", data: "Run not found" };
+                            break;
+                        }
+                        else if (run.status !== "pending") {
+                            break;
+                        }
                     }
                 }
-            }
-            if (signal?.aborted && threadId != null) {
-                await Runs.cancel(threadId, [runId], { action: "interrupt" });
-            }
+                if (signal?.aborted && threadId != null) {
+                    await Runs.cancel(threadId, [runId], { action: "interrupt" }, auth);
+                }
+            });
         }
         static async publish(runId, topic, data) {
             const queue = StreamManager.getQueue(runId, { ifNotFound: "create" });