@langchain/langgraph-sdk 1.9.2 → 1.9.3-rc.0

package/dist/client/stream/index.cjs

@@ -322,6 +322,7 @@ var ThreadStream = class {
 	#terminalPauseSeq;
 	#lifecycleSubId = null;
 	#lifecycleStartPromise;
+	#runStartReady = null;
 	#lifecycleWatcherHandle = null;
 	#lifecycleWatcherStartPromise;
 	#onEventListeners = /* @__PURE__ */ new Set();
@@ -378,11 +379,13 @@ var ThreadStream = class {
 		this.#fetchOption = options.fetch;
 		this.run = { start: async (params) => {
 			this.#prepareForNextRun();
-			this.#ensureLifecycleTracking();
-			this.values;
-			return await this.#send("run.start", {
-				...params,
-				assistant_id: this.assistantId
+			return await this.#withRunStartGate(() => {
+				this.#ensureLifecycleTracking();
+				this.values;
+				return this.#send("run.start", {
+					...params,
+					assistant_id: this.assistantId
+				});
 			});
 		} };
 		this.agent = { getTree: async (params = {}) => await this.#send("agent.getTree", params) };
@@ -440,6 +443,36 @@ var ThreadStream = class {
 		})().catch(() => void 0);
 	}
 	/**
+	* Run `operation` (a `run.start` send) while holding the run-start
+	* gate. Sets `#runStartReady` before invoking `operation` so any
+	* subscription kicked off synchronously inside it (e.g. the lifecycle
+	* watcher and the values projection) sees the gate when it eventually
+	* reaches `#startLifecycleWatcherSse` / `#reconcileStream` /
+	* `#subscribeViaCommand` and awaits it. The gate resolves the moment
+	* `operation` settles, so server-side subscribes land immediately
+	* after the thread is committed.
+	*/
+	async #withRunStartGate(operation) {
+		let resolveGate;
+		let rejectGate;
+		const gate = new Promise((resolve, reject) => {
+			resolveGate = resolve;
+			rejectGate = reject;
+		});
+		this.#runStartReady = gate;
+		gate.catch(() => void 0);
+		try {
+			const result = await operation();
+			resolveGate();
+			return result;
+		} catch (err) {
+			rejectGate(err);
+			throw err;
+		} finally {
+			if (this.#runStartReady === gate) this.#runStartReady = null;
+		}
+	}
+	/**
 	* Reset interrupt state and resume all paused user subscriptions.
 	* Called before `run.start()` and `input.respond()` so that
 	* iterators on the same handle pick up the next run's events.
@@ -782,10 +815,12 @@ var ThreadStream = class {
 	*/
 	async submitRun(params) {
 		this.#prepareForNextRun();
-		this.#startLifecycleWatcher();
-		return await this.#send("run.start", {
-			...params,
-			assistant_id: this.assistantId
+		return await this.#withRunStartGate(() => {
+			this.#startLifecycleWatcher();
+			return this.#send("run.start", {
+				...params,
+				assistant_id: this.assistantId
+			});
 		});
 	}
 	/**
@@ -851,7 +886,32 @@ var ThreadStream = class {
 		}
 		this.#lifecycleWatcherStartPromise = this.#startLifecycleWatcherWebSocket();
 	}
+	/**
+	* Public, idempotent entry point to start the wildcard lifecycle
+	* watcher.
+	*
+	* The watcher is normally started lazily by `submitRun` /
+	* `respondInput` because for fresh (self-created) threads the SSE
+	* stream would 404 if opened before the server has the thread row.
+	* Callers that already know the thread exists server-side
+	* (`StreamController.hydrate` of an existing thread) can use this
+	* to start the watcher up front. The watcher subscribes to wildcard
+	* lifecycle events across every namespace, so it sees arbitrarily-
+	* nested subagent lifecycle messages that the narrow root content
+	* pump (running at `depth: 1`) wouldn't reach — that's what makes
+	* subagent discovery work for historical thread loads.
+	*
+	* Idempotent — repeat calls reuse the in-flight start promise.
+	*/
+	startLifecycleWatcher() {
+		this.#startLifecycleWatcher();
+	}
 	async #startLifecycleWatcherSse() {
+		if (this.#runStartReady != null) try {
+			await this.#runStartReady;
+		} catch {
+			return;
+		}
 		const filter = { channels: ["lifecycle", "input"] };
 		let handle;
 		try {
@@ -1125,6 +1185,17 @@ var ThreadStream = class {
 		if (this.#rotationState === "rotating") return;
 		const desired = this.#computeUnionFilter();
 		if (desired == null) return;
+		if (this.#runStartReady != null) {
+			try {
+				await this.#runStartReady;
+			} catch (err) {
+				const normalized = err instanceof Error ? err : /* @__PURE__ */ new Error("run.start failed");
+				this.#rejectUncoveredPending(normalized);
+				return;
+			}
+			if (this.#closed) return;
+			if (this.#rotationState === "rotating") return;
+		}
 		if (this.#sharedStreamFilter != null && filterEqual(desired, this.#sharedStreamFilter) && this.#pendingSubResolves.length === 0) {
 			this.#resolvePending();
 			return;
@@ -1230,10 +1301,11 @@ var ThreadStream = class {
 	* matching buffered events on subscribe via the same WebSocket stream.
 	*/
 	async #subscribeViaCommand(params, transform) {
-		const result = await this.#send("subscription.subscribe", params);
-		const handle = new SubscriptionHandle(result.subscription_id, params, async (id) => {
-			this.#subscriptions.delete(id);
-			if (!this.#closed) await this.#send("subscription.unsubscribe", { subscription_id: id }).catch((err) => {
+		const placeholderId = `pending:${this.#nextCommandId}:${Math.random().toString(36).slice(2, 10)}`;
+		let resolvedId = placeholderId;
+		const handle = new SubscriptionHandle(placeholderId, params, async () => {
+			this.#subscriptions.delete(resolvedId);
+			if (!this.#closed && resolvedId !== placeholderId) await this.#send("subscription.unsubscribe", { subscription_id: resolvedId }).catch((err) => {
 				if (err instanceof require_error.ProtocolError && err.code === "no_such_subscription") return;
 				throw err;
 			});
@@ -1243,7 +1315,24 @@ var ThreadStream = class {
 			registeredAfterSeq: this.ordering.lastSeenSeq,
 			seenEventIds: /* @__PURE__ */ new Set()
 		});
-		this.#subscriptions.set(result.subscription_id, subscription);
+		this.#subscriptions.set(placeholderId, subscription);
+		if (this.#runStartReady != null) try {
+			await this.#runStartReady;
+		} catch (err) {
+			this.#subscriptions.delete(placeholderId);
+			throw err;
+		}
+		let result;
+		try {
+			result = await this.#send("subscription.subscribe", params);
+		} catch (err) {
+			this.#subscriptions.delete(placeholderId);
+			throw err;
+		}
+		this.#subscriptions.delete(placeholderId);
+		resolvedId = result.subscription_id;
+		handle.subscriptionId = resolvedId;
+		this.#subscriptions.set(resolvedId, subscription);
 		return handle;
 	}
 	async #consumeEvents() {