opencode-tbot 0.1.26 → 0.1.28

package/dist/plugin.js

@@ -218,6 +218,17 @@ var OpenCodePromptTimeoutError = class extends Error {
 		this.data = data;
 	}
 };
+var OpenCodeMessageAbortedError = class extends Error {
+	data;
+	constructor(message = "Request was aborted.") {
+		super(message);
+		this.name = "MessageAbortedError";
+		this.data = { message };
+	}
+};
+function createMessageAbortedError(message = "Request was aborted.") {
+	return new OpenCodeMessageAbortedError(message);
+}
 var EMPTY_RESPONSE_TEXT = "OpenCode returned empty response.";
 var PROMPT_MESSAGE_POLL_INITIAL_DELAYS_MS = [
 	0,
@@ -255,7 +266,6 @@ var StructuredReplySchema = z.object({ body_md: z.string() });
 var OpenCodeClient = class {
 	client;
 	fetchFn;
-	sdkFlavor;
 	promptTimeoutPolicy;
 	modelCache = {
 		expiresAt: 0,
@@ -266,7 +276,6 @@ var OpenCodeClient = class {
 		if (!options && !client) throw new Error("OpenCodeClient requires either base URL options or an injected SDK client.");
 		this.client = client ?? createOpencodeClient(buildOpenCodeSdkConfig(options));
 		this.fetchFn = fetchFn;
-		this.sdkFlavor = detectSdkFlavor(this.client);
 		this.promptTimeoutPolicy = resolvePromptTimeoutPolicy(promptTimeoutPolicy);
 	}
 	configurePromptTimeoutPolicy(promptTimeoutPolicy) {
@@ -279,169 +288,77 @@ var OpenCodeClient = class {
 		const target = this.client[scope];
 		const handler = target?.[method];
 		if (typeof handler !== "function") throw new Error(`OpenCode SDK client does not expose a compatible ${scope}.${method} method.`);
-		if (this.sdkFlavor === "legacy") return unwrapSdkData(await handler.call(target, {
-			...SDK_OPTIONS,
-			...input.signal ? { signal: input.signal } : {},
-			...input.legacyOptions ?? {}
-		}));
-		return unwrapSdkData(await handler.call(target, input.v2Parameters, {
+		const options = {
 			...SDK_OPTIONS,
 			...input.signal ? { signal: input.signal } : {}
-		}));
+		};
+		return unwrapSdkData(input.parameters === void 0 ? await handler.call(target, options) : await handler.call(target, input.parameters, options));
 	}
 	async getHealth() {
-		const rawClient = getRawSdkClient(this.client);
-		if (rawClient?.get) return await this.requestRaw("get", { url: "/global/health" });
-		const healthEndpoint = this.client.global?.health;
-		if (typeof healthEndpoint === "function") return unwrapSdkData(await healthEndpoint.call(this.client.global, SDK_OPTIONS));
-		if (!rawClient?.get) throw new Error("OpenCode SDK client does not expose a compatible health endpoint.");
-		return this.requestRaw("get", { url: "/global/health" });
+		try {
+			return await this.callScopedSdkMethod("global", "health", {});
+		} catch (error) {
+			if (!isMissingScopedSdkMethodError(error, "global", "health")) throw error;
+			return this.callRawSdkGet("/global/health");
+		}
 	}
 	async abortSession(sessionId) {
-		if (hasRawSdkMethod(this.client, "post")) return this.requestRaw("post", buildRawSessionRequest(this.sdkFlavor, sessionId, "/abort"));
-		return this.callScopedSdkMethod("session", "abort", {
-			legacyOptions: { path: { id: sessionId } },
-			v2Parameters: { sessionID: sessionId }
-		});
+		return this.callScopedSdkMethod("session", "abort", { parameters: { sessionID: sessionId } });
 	}
 	async deleteSession(sessionId) {
-		if (hasRawSdkMethod(this.client, "delete")) return this.requestRaw("delete", buildRawSessionRequest(this.sdkFlavor, sessionId));
-		return this.callScopedSdkMethod("session", "delete", {
-			legacyOptions: { path: { id: sessionId } },
-			v2Parameters: { sessionID: sessionId }
-		});
+		return this.callScopedSdkMethod("session", "delete", { parameters: { sessionID: sessionId } });
 	}
 	async forkSession(sessionId, messageId) {
-		if (hasRawSdkMethod(this.client, "post")) return this.requestRaw("post", buildRawSessionRequest(this.sdkFlavor, sessionId, "/fork", messageId?.trim() ? { body: { messageID: messageId.trim() } } : {}));
-		return this.callScopedSdkMethod("session", "fork", {
-			legacyOptions: {
-				path: { id: sessionId },
-				...messageId?.trim() ? { body: { messageID: messageId.trim() } } : {}
-			},
-			v2Parameters: {
-				sessionID: sessionId,
-				...messageId?.trim() ? { messageID: messageId.trim() } : {}
-			}
-		});
+		return this.callScopedSdkMethod("session", "fork", { parameters: {
+			sessionID: sessionId,
+			...messageId?.trim() ? { messageID: messageId.trim() } : {}
+		} });
 	}
 	async getPath() {
-		if (hasRawSdkMethod(this.client, "get")) return this.requestRaw("get", { url: "/path" });
 		return this.callScopedSdkMethod("path", "get", {});
 	}
 	async listLspStatuses(directory) {
-		if (hasRawSdkMethod(this.client, "get")) return this.requestRaw("get", {
-			url: "/lsp",
-			...directory ? { query: { directory } } : {}
-		});
-		return this.callScopedSdkMethod("lsp", "status", {
-			legacyOptions: directory ? { query: { directory } } : void 0,
-			v2Parameters: directory ? { directory } : void 0
-		});
+		return this.callScopedSdkMethod("lsp", "status", { parameters: directory ? { directory } : void 0 });
 	}
 	async listMcpStatuses(directory) {
-		if (hasRawSdkMethod(this.client, "get")) return this.requestRaw("get", {
-			url: "/mcp",
-			...directory ? { query: { directory } } : {}
-		});
-		return this.callScopedSdkMethod("mcp", "status", {
-			legacyOptions: directory ? { query: { directory } } : void 0,
-			v2Parameters: directory ? { directory } : void 0
-		});
+		return this.callScopedSdkMethod("mcp", "status", { parameters: directory ? { directory } : void 0 });
 	}
 	async getSessionStatuses() {
 		return this.loadSessionStatuses();
 	}
 	async listProjects() {
-		if (hasRawSdkMethod(this.client, "get")) return this.requestRaw("get", { url: "/project" });
 		return this.callScopedSdkMethod("project", "list", {});
 	}
 	async listSessions() {
-		if (hasRawSdkMethod(this.client, "get")) return this.requestRaw("get", { url: "/session" });
 		return this.callScopedSdkMethod("session", "list", {});
 	}
 	async getCurrentProject() {
-		if (hasRawSdkMethod(this.client, "get")) return this.requestRaw("get", { url: "/project/current" });
 		return this.callScopedSdkMethod("project", "current", {});
 	}
 	async createSessionForDirectory(directory, title) {
-		if (hasRawSdkMethod(this.client, "post")) return this.requestRaw("post", {
-			url: "/session",
-			query: { directory },
-			...title ? { body: { title } } : {}
-		});
-		return this.callScopedSdkMethod("session", "create", {
-			legacyOptions: {
-				query: { directory },
-				...title ? { body: { title } } : {}
-			},
-			v2Parameters: title ? {
-				directory,
-				title
-			} : { directory }
-		});
+		return this.callScopedSdkMethod("session", "create", { parameters: title ? {
+			directory,
+			title
+		} : { directory } });
 	}
 	async renameSession(sessionId, title) {
-		if (hasRawSdkMethod(this.client, "patch")) return this.requestRaw("patch", buildRawSessionRequest(this.sdkFlavor, sessionId, "", { body: { title } }));
-		return this.callScopedSdkMethod("session", "update", {
-			legacyOptions: {
-				path: { id: sessionId },
-				body: { title }
-			},
-			v2Parameters: {
-				sessionID: sessionId,
-				title
-			}
-		});
+		return this.callScopedSdkMethod("session", "update", { parameters: {
+			sessionID: sessionId,
+			title
+		} });
 	}
 	async listAgents() {
-		if (hasRawSdkMethod(this.client, "get")) return this.requestRaw("get", { url: "/agent" });
 		return this.callScopedSdkMethod("app", "agents", {});
 	}
 	async listPendingPermissions(directory) {
-		if (this.sdkFlavor === "v2" && hasRawSdkMethod(this.client, "get")) return this.requestRaw("get", {
-			url: "/permission",
-			...directory ? { query: { directory } } : {}
-		});
-		return this.callScopedSdkMethod("permission", "list", {
-			legacyOptions: directory ? { query: { directory } } : void 0,
-			v2Parameters: directory ? { directory } : void 0
-		});
+		return this.callScopedSdkMethod("permission", "list", { parameters: directory ? { directory } : void 0 });
 	}
-	async replyToPermission(requestId, reply, message, sessionId) {
-		if (this.sdkFlavor === "legacy" && sessionId) {
-			if (hasRawSdkMethod(this.client, "post")) return this.requestRaw("post", buildRawLegacyPermissionReplyRequest(sessionId, requestId, reply));
-			const legacyClient = this.client;
-			if (typeof legacyClient.postSessionIdPermissionsPermissionId === "function") return unwrapSdkData(await legacyClient.postSessionIdPermissionsPermissionId({
-				...SDK_OPTIONS,
-				body: { response: reply },
-				path: {
-					id: sessionId,
-					permissionID: requestId
-				}
-			}));
-		}
-		if (hasRawSdkMethod(this.client, "post")) return this.requestRaw("post", {
-			url: "/permission/{requestID}/reply",
-			path: { requestID: requestId },
-			body: {
-				reply,
-				...message?.trim() ? { message: message.trim() } : {}
-			}
-		});
-		return this.callScopedSdkMethod("permission", "reply", {
-			legacyOptions: sessionId ? {
-				body: { response: reply },
-				path: {
-					id: sessionId,
-					permissionID: requestId
-				}
-			} : void 0,
-			v2Parameters: {
-				requestID: requestId,
-				reply,
-				...message?.trim() ? { message: message.trim() } : {}
-			}
-		});
+	async replyToPermission(requestId, reply, message, _sessionId) {
+		return this.callScopedSdkMethod("permission", "reply", { parameters: {
+			requestID: requestId,
+			reply,
+			...message?.trim() ? { message: message.trim() } : {}
+		} });
 	}
 	async listModels() {
 		const now = Date.now();
@@ -466,9 +383,10 @@ var OpenCodeClient = class {
 			url: file.url
 		}))];
 		if (parts.length === 0) throw new Error("Prompt requires text or file attachments.");
-		const knownMessageIds = await this.captureKnownMessageIds(input.sessionId);
-		const initialData = await this.sendPromptRequest(input, parts);
-		return buildPromptSessionResult(await this.resolvePromptResponse(input, initialData, knownMessageIds, startedAt), {
+		throwIfAborted(input.signal);
+		const knownMessageIds = await this.captureKnownMessageIds(input.sessionId, input.signal);
+		await this.sendPromptRequest(input, parts);
+		return buildPromptSessionResult(await this.resolvePromptResponse(input, null, knownMessageIds, startedAt), {
 			emptyResponseText: EMPTY_RESPONSE_TEXT,
 			finishedAt: Date.now(),
 			startedAt,
@@ -488,10 +406,12 @@ var OpenCodeClient = class {
 		};
 		let bestCandidate = selectPromptResponseCandidate(data ? [data] : [], candidateOptions);
 		let lastProgressAt = Date.now();
+		let lastStatus = null;
 		const deadlineAt = startedAt + this.promptTimeoutPolicy.waitTimeoutMs;
 		let idleStatusSeen = false;
 		let attempt = 0;
 		while (true) {
+			throwIfAborted(input.signal);
 			const remainingWaitMs = deadlineAt - Date.now();
 			const remainingInactivityMs = this.promptTimeoutPolicy.recoveryInactivityTimeoutMs - (Date.now() - lastProgressAt);
 			if (remainingWaitMs <= 0 || remainingInactivityMs <= 0) break;
@@ -500,10 +420,10 @@ var OpenCodeClient = class {
 			if (delayMs > 0) {
 				const remainingMs = Math.min(remainingWaitMs, remainingInactivityMs);
 				if (remainingMs <= 0) break;
-				await delay(Math.min(delayMs, remainingMs));
+				await delay(Math.min(delayMs, remainingMs), input.signal);
 			}
 			if (messageId) {
-				const next = await this.fetchPromptMessage(input.sessionId, messageId);
+				const next = await this.fetchPromptMessage(input.sessionId, messageId, input.signal);
 				if (next) {
 					const nextCandidate = selectPromptResponseCandidate([bestCandidate, next], candidateOptions);
 					if (nextCandidate) {
@@ -513,10 +433,10 @@ var OpenCodeClient = class {
 						}
 						bestCandidate = nextCandidate;
 					}
-					if (bestCandidate && shouldReturnPromptResponseImmediately(bestCandidate, structured)) return bestCandidate;
+					if (bestCandidate && isPromptResponseForCurrentRequest(bestCandidate, candidateOptions) && shouldReturnPromptResponseImmediately(bestCandidate, structured)) return bestCandidate;
 				}
 			}
-			const latest = await this.findLatestPromptResponse(input.sessionId, candidateOptions, "poll-messages");
+			const latest = await this.findLatestPromptResponse(input.sessionId, candidateOptions, "poll-messages", input.signal);
 			if (latest) {
 				const nextCandidate = selectPromptResponseCandidate([bestCandidate, latest], candidateOptions);
 				if (nextCandidate) {
@@ -526,9 +446,10 @@ var OpenCodeClient = class {
 					}
 					bestCandidate = nextCandidate;
 				}
-				if (bestCandidate && shouldReturnPromptResponseImmediately(bestCandidate, structured)) return bestCandidate;
+				if (bestCandidate && isPromptResponseForCurrentRequest(bestCandidate, candidateOptions) && shouldReturnPromptResponseImmediately(bestCandidate, structured)) return bestCandidate;
 			}
-			const status = await this.fetchPromptSessionStatus(input.sessionId);
+			const status = await this.fetchPromptSessionStatus(input.sessionId, input.signal);
+			lastStatus = status;
 			if (status?.type === "busy" || status?.type === "retry") {
 				lastProgressAt = Date.now();
 				idleStatusSeen = false;
@@ -536,12 +457,14 @@ var OpenCodeClient = class {
 				if (idleStatusSeen) break;
 				idleStatusSeen = true;
 			}
-			if (bestCandidate && isCompletedEmptyPromptResponse(bestCandidate, structured) && status?.type !== "busy" && status?.type !== "retry") break;
+			if (bestCandidate && isPromptResponseForCurrentRequest(bestCandidate, candidateOptions) && isCompletedEmptyPromptResponse(bestCandidate, structured) && status?.type !== "busy" && status?.type !== "retry") break;
 			if (Date.now() >= deadlineAt) break;
 		}
-		const latest = await this.findLatestPromptResponse(input.sessionId, candidateOptions, "final-scan");
+		const latest = await this.findLatestPromptResponse(input.sessionId, candidateOptions, "final-scan", input.signal);
 		const resolved = selectPromptResponseCandidate([bestCandidate, latest], candidateOptions);
-		if (!resolved || shouldPollPromptMessage(resolved, structured)) {
+		const requestScopedResolved = resolved && isPromptResponseForCurrentRequest(resolved, candidateOptions) ? resolved : null;
+		if (lastStatus?.type === "idle" && (!requestScopedResolved || shouldPollPromptMessage(requestScopedResolved, structured))) throw createMessageAbortedError();
+		if (!requestScopedResolved || shouldPollPromptMessage(requestScopedResolved, structured)) {
 			const timeoutReason = Date.now() >= deadlineAt ? "max-wait" : "recovery-inactivity";
 			const timeoutMs = timeoutReason === "max-wait" ? this.promptTimeoutPolicy.waitTimeoutMs : this.promptTimeoutPolicy.recoveryInactivityTimeoutMs;
 			const error = createOpenCodePromptTimeoutError({
@@ -553,7 +476,6 @@ var OpenCodeClient = class {
 			this.logPromptRequest("warn", {
 				lastProgressAt,
 				messageId: messageId ?? void 0,
-				sdkFlavor: this.sdkFlavor,
 				sessionId: input.sessionId,
 				stage: "final-scan",
 				timeoutMs,
@@ -561,31 +483,26 @@ var OpenCodeClient = class {
 			}, "OpenCode prompt recovery timed out");
 			throw error;
 		}
-		return resolved;
+		return requestScopedResolved;
 	}
-	async fetchPromptMessage(sessionId, messageId) {
+	async fetchPromptMessage(sessionId, messageId, signal) {
 		try {
 			return await this.runPromptRequestWithTimeout({
 				sessionId,
 				stage: "poll-message",
 				timeoutMs: this.promptTimeoutPolicy.pollRequestTimeoutMs,
 				messageId
-			}, async (signal) => {
-				if (hasRawSdkMethod(this.client, "get")) return normalizePromptResponse(await this.requestRaw("get", buildRawSessionMessageRequest(this.sdkFlavor, sessionId, messageId, { signal })));
-				if (typeof this.client.session.message !== "function") return null;
+			}, async (requestSignal) => {
 				return normalizePromptResponse(await this.callScopedSdkMethod("session", "message", {
-					legacyOptions: { path: {
-						id: sessionId,
-						messageID: messageId
-					} },
-					signal,
-					v2Parameters: {
+					parameters: {
 						sessionID: sessionId,
 						messageID: messageId
-					}
+					},
+					signal: requestSignal
 				}));
-			});
+			}, signal);
 		} catch (error) {
+			if (isPromptRequestAbort(error)) throw error;
 			this.logPromptRequestFailure(error, {
 				sessionId,
 				stage: "poll-message",
@@ -595,36 +512,28 @@ var OpenCodeClient = class {
 			return null;
 		}
 	}
-	async captureKnownMessageIds(sessionId) {
-		const messages = await this.fetchRecentPromptMessages(sessionId, "capture-known-messages");
+	async captureKnownMessageIds(sessionId, signal) {
+		const messages = await this.fetchRecentPromptMessages(sessionId, "capture-known-messages", signal);
 		if (!messages) return /* @__PURE__ */ new Set();
 		return new Set(messages.map((message) => extractMessageId(message.info)).filter((id) => typeof id === "string" && id.length > 0));
 	}
-	async fetchRecentPromptMessages(sessionId, stage) {
+	async fetchRecentPromptMessages(sessionId, stage, signal) {
 		try {
 			return await this.runPromptRequestWithTimeout({
 				sessionId,
 				stage,
 				timeoutMs: this.promptTimeoutPolicy.pollRequestTimeoutMs
-			}, async (signal) => {
-				if (hasRawSdkMethod(this.client, "get")) return normalizePromptResponses(await this.requestRaw("get", buildRawSessionRequest(this.sdkFlavor, sessionId, "/message", {
-					query: { limit: PROMPT_MESSAGE_POLL_LIMIT },
-					signal
-				})));
-				if (typeof this.client.session.messages !== "function") return null;
+			}, async (requestSignal) => {
 				return normalizePromptResponses(await this.callScopedSdkMethod("session", "messages", {
-					legacyOptions: {
-						path: { id: sessionId },
-						query: { limit: PROMPT_MESSAGE_POLL_LIMIT }
-					},
-					signal,
-					v2Parameters: {
+					parameters: {
 						sessionID: sessionId,
 						limit: PROMPT_MESSAGE_POLL_LIMIT
-					}
+					},
+					signal: requestSignal
 				}));
-			});
+			}, signal);
 		} catch (error) {
+			if (isPromptRequestAbort(error)) throw error;
 			this.logPromptRequestFailure(error, {
 				sessionId,
 				stage,
@@ -633,14 +542,15 @@ var OpenCodeClient = class {
 			return null;
 		}
 	}
-	async fetchPromptSessionStatus(sessionId) {
+	async fetchPromptSessionStatus(sessionId, signal) {
 		try {
 			return (await this.runPromptRequestWithTimeout({
 				sessionId,
 				stage: "poll-status",
 				timeoutMs: this.promptTimeoutPolicy.pollRequestTimeoutMs
-			}, async (signal) => this.loadSessionStatuses(signal)))[sessionId] ?? null;
+			}, async (requestSignal) => this.loadSessionStatuses(requestSignal), signal))[sessionId] ?? null;
 		} catch (error) {
+			if (isPromptRequestAbort(error)) throw error;
 			this.logPromptRequestFailure(error, {
 				sessionId,
 				stage: "poll-status",
@@ -649,8 +559,8 @@ var OpenCodeClient = class {
 			return null;
 		}
 	}
-	async findLatestPromptResponse(sessionId, options, stage) {
-		const messages = await this.fetchRecentPromptMessages(sessionId, stage);
+	async findLatestPromptResponse(sessionId, options, stage, signal) {
+		const messages = await this.fetchRecentPromptMessages(sessionId, stage, signal);
 		if (!messages || messages.length === 0) return null;
 		return selectPromptResponseCandidate(messages, options);
 	}
@@ -666,11 +576,9 @@ var OpenCodeClient = class {
 		return models;
 	}
 	async loadConfig() {
-		if (hasRawSdkMethod(this.client, "get")) return this.requestRaw("get", { url: "/config" });
 		return this.callScopedSdkMethod("config", "get", {});
 	}
 	async loadProviderCatalog() {
-		if (hasRawSdkMethod(this.client, "get")) return this.requestRaw("get", { url: "/config/providers" });
 		return this.callScopedSdkMethod("config", "providers", {});
 	}
 	async sendPromptRequest(input, parts) {
@@ -686,26 +594,6 @@ var OpenCodeClient = class {
 			...requestBody
 		};
 		try {
-			if (hasRawSdkMethod(this.client, "post")) return await this.runPromptRequestWithTimeout({
-				sessionId: input.sessionId,
-				stage: "send-prompt",
-				timeoutMs: this.promptTimeoutPolicy.waitTimeoutMs
-			}, async (signal) => normalizePromptResponse(await this.requestRaw("post", buildRawSessionRequest(this.sdkFlavor, input.sessionId, "/message", {
-				body: requestBody,
-				signal
-			}))));
-			if (typeof this.client.session?.prompt === "function") return await this.runPromptRequestWithTimeout({
-				sessionId: input.sessionId,
-				stage: "send-prompt",
-				timeoutMs: this.promptTimeoutPolicy.waitTimeoutMs
-			}, async (signal) => normalizePromptResponse(await this.callScopedSdkMethod("session", "prompt", {
-				legacyOptions: {
-					body: requestBody,
-					path: { id: input.sessionId }
-				},
-				signal,
-				v2Parameters: requestParameters
-			})));
 			if (typeof this.client.session?.promptAsync === "function") {
 				await this.runPromptRequestWithTimeout({
 					sessionId: input.sessionId,
@@ -713,15 +601,11 @@ var OpenCodeClient = class {
 					timeoutMs: this.promptTimeoutPolicy.waitTimeoutMs
 				}, async (signal) => {
 					await this.callScopedSdkMethod("session", "promptAsync", {
-						legacyOptions: {
-							body: requestBody,
-							path: { id: input.sessionId }
-						},
-						signal,
-						v2Parameters: requestParameters
+						parameters: requestParameters,
+						signal
 					});
-				});
-				return null;
+				}, input.signal);
+				return;
 			}
 		} catch (error) {
 			this.logPromptRequestFailure(error, {
@@ -731,27 +615,42 @@ var OpenCodeClient = class {
 			});
 			throw error;
 		}
-		throw new Error("OpenCode SDK client does not expose a compatible prompt endpoint.");
-	}
-	async requestRaw(method, options) {
-		const handler = getRawSdkClient(this.client)?.[method];
-		if (typeof handler !== "function") throw new Error(`OpenCode SDK client does not expose a compatible raw ${method.toUpperCase()} method.`);
-		return unwrapSdkData(await handler({
-			...SDK_OPTIONS,
-			...options
-		}));
+		throw new Error("OpenCode SDK client does not expose session.promptAsync().");
 	}
 	async loadSessionStatuses(signal) {
-		if (hasRawSdkMethod(this.client, "get")) return this.requestRaw("get", {
-			url: "/session/status",
-			...signal ? { signal } : {}
+		return this.callScopedSdkMethod("session", "status", {
+			signal,
+			parameters: void 0
 		});
-		return this.callScopedSdkMethod("session", "status", { signal });
 	}
-	async runPromptRequestWithTimeout(input, operation) {
+	async callRawSdkGet(url, signal) {
+		const rawClient = getRawSdkRequestClient(this.client);
+		if (typeof rawClient?.get !== "function") throw new Error(`OpenCode SDK client does not expose a compatible raw GET endpoint for ${url}.`);
+		return unwrapSdkData(await rawClient.get({
+			...SDK_OPTIONS,
+			...signal ? { signal } : {},
+			url
+		}));
+	}
+	async runPromptRequestWithTimeout(input, operation, signal) {
 		const startedAt = Date.now();
 		const controller = new AbortController();
+		const requestSignal = signal ? AbortSignal.any([signal, controller.signal]) : controller.signal;
 		let timeoutHandle = null;
+		let removeAbortListener = () => void 0;
+		const abortPromise = signal ? new Promise((_, reject) => {
+			const onAbort = () => {
+				reject(normalizeAbortReason(signal.reason));
+			};
+			if (signal.aborted) {
+				onAbort();
+				return;
+			}
+			signal.addEventListener("abort", onAbort, { once: true });
+			removeAbortListener = () => {
+				signal.removeEventListener("abort", onAbort);
+			};
+		}) : null;
 		const timeoutPromise = new Promise((_, reject) => {
 			timeoutHandle = setTimeout(() => {
 				reject(createOpenCodePromptTimeoutError({
@@ -765,9 +664,14 @@ var OpenCodeClient = class {
 			}, input.timeoutMs);
 		});
 		try {
-			return await Promise.race([operation(controller.signal), timeoutPromise]);
+			return await Promise.race([
+				operation(requestSignal),
+				timeoutPromise,
+				...abortPromise ? [abortPromise] : []
+			]);
 		} finally {
 			if (timeoutHandle !== null) clearTimeout(timeoutHandle);
+			removeAbortListener();
 		}
 	}
 	logPromptRequestFailure(error, input) {
@@ -776,7 +680,6 @@ var OpenCodeClient = class {
 				endpointKind: resolvePromptEndpointKind(error.data.stage),
 				elapsedMs: error.data.elapsedMs,
 				messageId: error.data.messageId,
-				sdkFlavor: this.sdkFlavor,
 				sessionId: error.data.sessionId,
 				stage: error.data.stage,
 				timeoutMs: error.data.timeoutMs
@@ -787,7 +690,6 @@ var OpenCodeClient = class {
 			endpointKind: resolvePromptEndpointKind(input.stage),
 			error,
 			messageId: input.messageId ?? void 0,
-			sdkFlavor: this.sdkFlavor,
 			sessionId: input.sessionId,
 			stage: input.stage,
 			timeoutMs: input.timeoutMs
@@ -978,8 +880,23 @@ function extractMessageId(message) {
 	if (!isPlainRecord(message)) return null;
 	return typeof message.id === "string" && message.id.trim().length > 0 ? message.id : null;
 }
-function delay(ms) {
-	return new Promise((resolve) => setTimeout(resolve, ms));
+function delay(ms, signal) {
+	return new Promise((resolve, reject) => {
+		const handle = setTimeout(() => {
+			signal?.removeEventListener("abort", onAbort);
+			resolve();
+		}, ms);
+		const onAbort = () => {
+			clearTimeout(handle);
+			signal?.removeEventListener("abort", onAbort);
+			reject(normalizeAbortReason(signal?.reason));
+		};
+		if (signal?.aborted) {
+			onAbort();
+			return;
+		}
+		signal?.addEventListener("abort", onAbort, { once: true });
+	});
 }
 function didPromptResponseAdvance(previous, next, structured) {
 	return getPromptResponseProgressSignature(previous, structured) !== getPromptResponseProgressSignature(next, structured);
@@ -1056,6 +973,13 @@ function unwrapSdkData(response) {
 	if (response && typeof response === "object" && "data" in response) return response.data;
 	return response;
 }
+function getRawSdkRequestClient(client) {
+	const compatibleClient = client;
+	return compatibleClient.client ?? compatibleClient._client ?? null;
+}
+function isMissingScopedSdkMethodError(error, scope, method) {
+	return error instanceof Error && error.message === `OpenCode SDK client does not expose a compatible ${scope}.${method} method.`;
+}
 function resolvePromptTimeoutPolicy(input) {
 	return {
 		pollRequestTimeoutMs: input.pollRequestTimeoutMs ?? DEFAULT_OPENCODE_PROMPT_TIMEOUT_POLICY.pollRequestTimeoutMs,
@@ -1063,46 +987,6 @@ function resolvePromptTimeoutPolicy(input) {
 		waitTimeoutMs: input.waitTimeoutMs ?? DEFAULT_OPENCODE_PROMPT_TIMEOUT_POLICY.waitTimeoutMs
 	};
 }
-function detectSdkFlavor(client) {
-	if (typeof client.global?.health === "function" || "permission" in client) return "v2";
-	return clientExposesTwoArgumentSdkMethod(client) ? "v2" : "legacy";
-}
-function buildRawSessionRequest(sdkFlavor, sessionId, suffix = "", extra = {}) {
-	return {
-		url: sdkFlavor === "legacy" ? `/session/{id}${suffix}` : `/session/{sessionID}${suffix}`,
-		path: sdkFlavor === "legacy" ? { id: sessionId } : { sessionID: sessionId },
-		...extra
-	};
-}
-function buildRawSessionMessageRequest(sdkFlavor, sessionId, messageId, extra = {}) {
-	return {
-		url: sdkFlavor === "legacy" ? "/session/{id}/message/{messageID}" : "/session/{sessionID}/message/{messageID}",
-		path: sdkFlavor === "legacy" ? {
-			id: sessionId,
-			messageID: messageId
-		} : {
-			sessionID: sessionId,
-			messageID: messageId
-		},
-		...extra
-	};
-}
-function buildRawLegacyPermissionReplyRequest(sessionId, requestId, reply) {
-	return {
-		body: { response: reply },
-		path: {
-			id: sessionId,
-			permissionID: requestId
-		},
-		url: "/session/{id}/permissions/{permissionID}"
-	};
-}
-function getRawSdkClient(client) {
-	return client.client ?? client._client ?? null;
-}
-function hasRawSdkMethod(client, method) {
-	return typeof getRawSdkClient(client)?.[method] === "function";
-}
 function normalizeAssistantError(value) {
 	if (!isPlainRecord(value) || typeof value.name !== "string" || value.name.trim().length === 0) return;
 	return {
@@ -1120,23 +1004,6 @@ function isCompletedEmptyPromptResponse(data, structured) {
 	const hasText = extractTextFromParts(Array.isArray(data.parts) ? data.parts : []).length > 0;
 	return isAssistantMessageCompleted(assistantInfo) && !assistantInfo?.error && !hasText && !bodyMd;
 }
-function clientExposesTwoArgumentSdkMethod(client) {
-	return [
-		"app",
-		"config",
-		"global",
-		"lsp",
-		"mcp",
-		"path",
-		"permission",
-		"project",
-		"session"
-	].some((scope) => {
-		const target = client[scope];
-		if (!target || typeof target !== "object") return false;
-		return Object.values(target).some((value) => typeof value === "function" && value.length >= 2);
-	});
-}
 function extractStructuredPayload(message) {
 	if (!isPlainRecord(message)) return null;
 	if ("structured" in message && message.structured !== void 0) return message.structured;
@@ -1151,7 +1018,7 @@ function selectPromptResponseCandidate(candidates, options) {
 function comparePromptResponseCandidates(left, right, options) {
 	const leftRank = getPromptResponseCandidateRank(left, options);
 	const rightRank = getPromptResponseCandidateRank(right, options);
-	return Number(rightRank.isUsable) - Number(leftRank.isUsable) || Number(rightRank.isInitial) - Number(leftRank.isInitial) || Number(rightRank.sharesParent) - Number(leftRank.sharesParent) || Number(rightRank.isNewSinceRequestStart) - Number(leftRank.isNewSinceRequestStart) || rightRank.createdAt - leftRank.createdAt;
+	return Number(rightRank.isInitial) - Number(leftRank.isInitial) || Number(rightRank.sharesParent) - Number(leftRank.sharesParent) || Number(rightRank.isNewSinceRequestStart) - Number(leftRank.isNewSinceRequestStart) || Number(rightRank.isUsable) - Number(leftRank.isUsable) || rightRank.createdAt - leftRank.createdAt;
 }
 function getPromptResponseCandidateRank(message, options) {
 	const assistant = toAssistantMessage(message.info);
@@ -1166,7 +1033,7 @@ function getPromptResponseCandidateRank(message, options) {
 	};
 }
 function resolvePromptCandidateStartTime(startedAt, initialMessage) {
-	if (!initialMessage) return null;
+	if (!initialMessage) return startedAt;
 	const initialCreatedAt = coerceFiniteNumber(toAssistantMessage(initialMessage.info)?.time?.created);
 	if (initialCreatedAt === null) return startedAt;
 	return areComparablePromptTimestamps(startedAt, initialCreatedAt) ? startedAt : initialCreatedAt;
@@ -1190,10 +1057,28 @@ function isPromptResponseNewSinceRequestStart(messageId, createdAt, knownMessage
 	if (requestStartedAt === null) return true;
 	return createdAt >= requestStartedAt;
 }
+function isPromptResponseForCurrentRequest(response, options) {
+	const rank = getPromptResponseCandidateRank(response, options);
+	return rank.isInitial || rank.sharesParent || rank.isNewSinceRequestStart;
+}
 function areComparablePromptTimestamps(left, right) {
 	const epochThresholdMs = 0xe8d4a51000;
 	return left >= epochThresholdMs && right >= epochThresholdMs;
 }
+function isPromptRequestAbort(error) {
+	return error instanceof OpenCodeMessageAbortedError || error instanceof Error && error.name === "AbortError" || isNamedAbortError(error);
+}
+function isNamedAbortError(error) {
+	return !!error && typeof error === "object" && "name" in error && error.name === "MessageAbortedError";
+}
+function normalizeAbortReason(reason) {
+	if (reason instanceof Error || isNamedAbortError(reason)) return reason;
+	return createMessageAbortedError();
+}
+function throwIfAborted(signal) {
+	if (!signal?.aborted) return;
+	throw normalizeAbortReason(signal.reason);
+}
 function isPlainRecord(value) {
 	return value !== null && typeof value === "object" && !Array.isArray(value);
 }
@@ -1361,85 +1246,119 @@ function extractErrorMessage(error) {
 //#endregion
 //#region src/services/session-activity/foreground-session-tracker.ts
 var ForegroundSessionTracker = class {
-	chatStacks = /* @__PURE__ */ new Map();
-	counts = /* @__PURE__ */ new Map();
+	requests = /* @__PURE__ */ new Map();
 	sessionChats = /* @__PURE__ */ new Map();
+	acquire(chatId) {
+		if (this.requests.has(chatId)) return null;
+		const state = {
+			chatId,
+			controller: new AbortController(),
+			sessionId: null
+		};
+		this.requests.set(chatId, state);
+		return {
+			signal: state.controller.signal,
+			attachSession: (sessionId) => {
+				this.attachSession(chatId, sessionId);
+			},
+			dispose: () => {
+				this.release(chatId);
+			}
+		};
+	}
+	abort(chatId, reason = createMessageAbortedError()) {
+		const state = this.requests.get(chatId);
+		if (!state) return false;
+		if (!state.controller.signal.aborted) state.controller.abort(reason);
+		return true;
+	}
 	begin(chatId, sessionId) {
-		const currentCount = this.counts.get(sessionId) ?? 0;
-		this.counts.set(sessionId, currentCount + 1);
-		this.incrementChat(chatId, sessionId);
+		const lease = this.acquire(chatId);
+		if (!lease) return () => void 0;
+		lease.attachSession(sessionId);
 		return () => {
-			this.decrement(chatId, sessionId);
+			lease.dispose();
 		};
 	}
 	clear(sessionId) {
-		const wasForeground = this.counts.has(sessionId);
-		const chatCounts = this.sessionChats.get(sessionId);
-		this.counts.delete(sessionId);
-		this.sessionChats.delete(sessionId);
-		for (const chatId of chatCounts?.keys() ?? []) {
-			const stack = this.chatStacks.get(chatId);
-			if (!stack) continue;
-			const nextStack = stack.filter((trackedSessionId) => trackedSessionId !== sessionId);
-			if (nextStack.length === 0) {
-				this.chatStacks.delete(chatId);
-				continue;
-			}
-			this.chatStacks.set(chatId, nextStack);
+		const chatIds = this.listChatIds(sessionId);
+		if (chatIds.length === 0) return false;
+		for (const chatId of chatIds) {
+			const state = this.requests.get(chatId);
+			if (state?.sessionId === sessionId) state.sessionId = null;
 		}
-		return wasForeground;
+		this.sessionChats.delete(sessionId);
+		return true;
+	}
+	fail(sessionId, error) {
+		const chatIds = this.listChatIds(sessionId);
+		if (chatIds.length === 0) return false;
+		this.clear(sessionId);
+		for (const chatId of chatIds) this.abort(chatId, error);
+		return true;
 	}
 	getActiveSessionId(chatId) {
-		return this.chatStacks.get(chatId)?.at(-1) ?? null;
+		return this.requests.get(chatId)?.sessionId ?? null;
+	}
+	hasActiveRequest(chatId) {
+		return this.requests.has(chatId);
 	}
 	isForeground(sessionId) {
-		return this.counts.has(sessionId);
+		return this.sessionChats.has(sessionId);
 	}
 	listChatIds(sessionId) {
-		return [...this.sessionChats.get(sessionId)?.keys() ?? []];
-	}
-	decrement(chatId, sessionId) {
-		const currentCount = this.counts.get(sessionId);
-		if (!currentCount || currentCount <= 1) this.counts.delete(sessionId);
-		else this.counts.set(sessionId, currentCount - 1);
-		this.decrementChat(chatId, sessionId);
-	}
-	incrementChat(chatId, sessionId) {
-		const stack = this.chatStacks.get(chatId) ?? [];
-		stack.push(sessionId);
-		this.chatStacks.set(chatId, stack);
-		const chatCounts = this.sessionChats.get(sessionId) ?? /* @__PURE__ */ new Map();
-		const currentCount = chatCounts.get(chatId) ?? 0;
-		chatCounts.set(chatId, currentCount + 1);
-		this.sessionChats.set(sessionId, chatCounts);
-	}
-	decrementChat(chatId, sessionId) {
-		const stack = this.chatStacks.get(chatId);
-		if (stack) {
-			const index = stack.lastIndexOf(sessionId);
-			if (index >= 0) stack.splice(index, 1);
-			if (stack.length === 0) this.chatStacks.delete(chatId);
-			else this.chatStacks.set(chatId, stack);
+		return [...this.sessionChats.get(sessionId) ?? /* @__PURE__ */ new Set()];
+	}
+	attachSession(chatId, sessionId) {
+		const normalizedSessionId = sessionId.trim();
+		const state = this.requests.get(chatId);
+		if (!state || normalizedSessionId.length === 0) return;
+		if (state.sessionId === normalizedSessionId) return;
+		if (state.sessionId) this.detachChatFromSession(chatId, state.sessionId);
+		state.sessionId = normalizedSessionId;
+		const chatIds = this.sessionChats.get(normalizedSessionId) ?? /* @__PURE__ */ new Set();
+		chatIds.add(chatId);
+		this.sessionChats.set(normalizedSessionId, chatIds);
+	}
+	release(chatId) {
+		const state = this.requests.get(chatId);
+		if (!state) return;
+		if (state.sessionId) this.detachChatFromSession(chatId, state.sessionId);
+		this.requests.delete(chatId);
+	}
+	detachChatFromSession(chatId, sessionId) {
+		const chatIds = this.sessionChats.get(sessionId);
+		if (!chatIds) return;
+		chatIds.delete(chatId);
+		if (chatIds.size === 0) {
+			this.sessionChats.delete(sessionId);
+			return;
 		}
-		const chatCounts = this.sessionChats.get(sessionId);
-		if (!chatCounts) return;
-		const currentCount = chatCounts.get(chatId) ?? 0;
-		if (currentCount <= 1) chatCounts.delete(chatId);
-		else chatCounts.set(chatId, currentCount - 1);
-		if (chatCounts.size === 0) this.sessionChats.delete(sessionId);
-		else this.sessionChats.set(sessionId, chatCounts);
+		this.sessionChats.set(sessionId, chatIds);
 	}
 };
 var NOOP_FOREGROUND_SESSION_TRACKER = {
+	acquire() {
+		return null;
+	},
+	abort() {
+		return false;
+	},
 	begin() {
 		return () => void 0;
 	},
 	clear() {
 		return false;
 	},
+	fail() {
+		return false;
+	},
 	getActiveSessionId() {
 		return null;
 	},
+	hasActiveRequest() {
+		return false;
+	},
 	isForeground() {
 		return false;
 	},
@@ -1456,23 +1375,40 @@ var AbortPromptUseCase = class {
 		this.foregroundSessionTracker = foregroundSessionTracker;
 	}
 	async execute(input) {
+		const hasForegroundRequest = this.foregroundSessionTracker.hasActiveRequest(input.chatId);
 		const activeSessionId = this.foregroundSessionTracker.getActiveSessionId(input.chatId);
 		const binding = activeSessionId ? null : await this.sessionRepo.getByChatId(input.chatId);
 		const sessionId = activeSessionId ?? binding?.sessionId ?? null;
-		if (!sessionId) return {
+		if (!hasForegroundRequest && !sessionId) return {
 			sessionId: null,
 			status: "no_session",
 			sessionStatus: null
 		};
-		const sessionStatus = (await this.opencodeClient.getSessionStatuses())[sessionId] ?? null;
+		const sessionStatuses = sessionId ? await this.opencodeClient.getSessionStatuses() : {};
+		const sessionStatus = sessionId ? sessionStatuses[sessionId] ?? null : null;
+		if (hasForegroundRequest) {
+			if (sessionId && sessionStatus && sessionStatus.type !== "idle") await this.opencodeClient.abortSession(sessionId);
+			this.foregroundSessionTracker.abort(input.chatId, createMessageAbortedError());
+			return {
+				sessionId,
+				status: "aborted",
+				sessionStatus
+			};
+		}
 		if (!sessionStatus || sessionStatus.type === "idle") return {
 			sessionId,
 			status: "not_running",
 			sessionStatus
 		};
+		if (!sessionId) return {
+			sessionId: null,
+			status: "not_running",
+			sessionStatus
+		};
+		const runningSessionId = sessionId;
 		return {
-			sessionId,
-			status: await this.opencodeClient.abortSession(sessionId) ? "aborted" : "not_running",
+			sessionId: runningSessionId,
+			status: await this.opencodeClient.abortSession(runningSessionId) ? "aborted" : "not_running",
 			sessionStatus
 		};
 	}
@@ -1914,11 +1850,10 @@ var RenameSessionUseCase = class {
 //#endregion
 //#region src/use-cases/send-prompt.usecase.ts
 var SendPromptUseCase = class {
-	constructor(sessionRepo, opencodeClient, logger, foregroundSessionTracker = NOOP_FOREGROUND_SESSION_TRACKER) {
+	constructor(sessionRepo, opencodeClient, logger) {
 		this.sessionRepo = sessionRepo;
 		this.opencodeClient = opencodeClient;
 		this.logger = logger;
-		this.foregroundSessionTracker = foregroundSessionTracker;
 	}
 	async execute(input) {
 		const files = input.files ?? [];
@@ -1972,7 +1907,7 @@ var SendPromptUseCase = class {
 		}
 		const temporarySessionId = shouldIsolateImageTurn ? await this.createTemporaryImageSession(input.chatId, activeBinding.sessionId) : null;
 		const executionSessionId = temporarySessionId ?? activeBinding.sessionId;
-		const endForegroundSession = this.foregroundSessionTracker.begin(input.chatId, executionSessionId);
+		input.onExecutionSession?.(executionSessionId);
 		let result;
 		try {
 			result = await this.opencodeClient.promptSession({
@@ -1982,10 +1917,10 @@ var SendPromptUseCase = class {
 				...selectedAgent ? { agent: selectedAgent.name } : {},
 				structured: true,
 				...model ? { model } : {},
+				...input.signal ? { signal: input.signal } : {},
 				...activeBinding.modelVariant ? { variant: activeBinding.modelVariant } : {}
 			});
 		} finally {
-			endForegroundSession();
 			if (temporarySessionId) await this.cleanupTemporaryImageSession(input.chatId, activeBinding.sessionId, temporarySessionId);
 		}
 		await this.sessionRepo.touch(input.chatId);
@@ -2253,7 +2188,7 @@ function createContainer(config, opencodeClient, logger) {
 	const getStatusUseCase = new GetStatusUseCase(getHealthUseCase, getPathUseCase, listLspUseCase, listMcpUseCase, listSessionsUseCase, sessionRepo);
 	const listModelsUseCase = new ListModelsUseCase(sessionRepo, opencodeClient);
 	const renameSessionUseCase = new RenameSessionUseCase(sessionRepo, opencodeClient, logger);
-	const sendPromptUseCase = new SendPromptUseCase(sessionRepo, opencodeClient, logger, foregroundSessionTracker);
+	const sendPromptUseCase = new SendPromptUseCase(sessionRepo, opencodeClient, logger);
 	const switchAgentUseCase = new SwitchAgentUseCase(sessionRepo, opencodeClient, logger);
 	const switchModelUseCase = new SwitchModelUseCase(sessionRepo, opencodeClient, logger);
 	const switchSessionUseCase = new SwitchSessionUseCase(sessionRepo, opencodeClient, logger);
@@ -2360,21 +2295,25 @@ function escapeMarkdownV2(value) {
 async function handleTelegramBotPluginEvent(runtime, event) {
 	switch (event.type) {
 		case "permission.asked":
-			await handlePermissionAsked(runtime, event.properties);
+			await handlePermissionAsked(runtime, event);
 			return;
 		case "permission.replied":
-			await handlePermissionReplied(runtime, event.properties.requestID, event.properties.reply);
+			await handlePermissionReplied(runtime, event);
 			return;
 		case "session.error":
-			await handleSessionError(runtime, event.properties.sessionID, event.properties.error);
+			await handleSessionError(runtime, event);
 			return;
 		case "session.idle":
-			await handleSessionIdle(runtime, event.properties.sessionID);
+			await handleSessionIdle(runtime, event);
+			return;
+		case "session.status":
+			await handleSessionStatus(runtime, event);
 			return;
 		default: return;
 	}
 }
-async function handlePermissionAsked(runtime, request) {
+async function handlePermissionAsked(runtime, event) {
+	const request = event.properties;
 	const bindings = await runtime.container.sessionRepo.listBySessionId(request.sessionID);
 	const chatIds = new Set([...bindings.map((binding) => binding.chatId), ...runtime.container.foregroundSessionTracker.listChatIds(request.sessionID)]);
 	const approvals = await runtime.container.permissionApprovalRepo.listByRequestId(request.id);
@@ -2403,7 +2342,9 @@ async function handlePermissionAsked(runtime, request) {
 		}
 	}
 }
-async function handlePermissionReplied(runtime, requestId, reply) {
+async function handlePermissionReplied(runtime, event) {
+	const requestId = event.properties.requestID;
+	const reply = event.properties.reply;
 	const approvals = await runtime.container.permissionApprovalRepo.listByRequestId(requestId);
 	await Promise.all(approvals.map(async (approval) => {
 		try {
@@ -2418,27 +2359,37 @@ async function handlePermissionReplied(runtime, requestId, reply) {
 		await runtime.container.permissionApprovalRepo.set(toResolvedApproval(approval, reply));
 	}));
 }
-async function handleSessionError(runtime, sessionId, error) {
+async function handleSessionError(runtime, event) {
+	const sessionId = event.properties.sessionID;
+	const error = event.properties.error;
 	if (!sessionId) {
 		runtime.container.logger.error({ error }, "session error received without a session id");
 		return;
 	}
-	if (runtime.container.foregroundSessionTracker.clear(sessionId)) {
+	if (runtime.container.foregroundSessionTracker.fail(sessionId, error ?? /* @__PURE__ */ new Error("Unknown session error."))) {
 		runtime.container.logger.warn({
 			error,
 			sessionId
 		}, "session error suppressed for foreground Telegram session");
 		return;
 	}
-	await notifyBoundChats(runtime, sessionId, `Session failed.\n\nSession: ${sessionId}\nError: ${error?.data?.message?.trim() || error?.name?.trim() || "Unknown session error."}`);
+	await notifyBoundChats(runtime, sessionId, `Session failed.\n\nSession: ${sessionId}\nError: ${(typeof error?.data?.message === "string" ? error.data.message.trim() : "") || error?.name?.trim() || "Unknown session error."}`);
 }
-async function handleSessionIdle(runtime, sessionId) {
+async function handleSessionIdle(runtime, event) {
+	const sessionId = event.properties.sessionID;
 	if (runtime.container.foregroundSessionTracker.clear(sessionId)) {
 		runtime.container.logger.info({ sessionId }, "session idle notification suppressed for foreground Telegram session");
 		return;
 	}
 	await notifyBoundChats(runtime, sessionId, `Session finished.\n\nSession: ${sessionId}`);
 }
+async function handleSessionStatus(runtime, event) {
+	if (event.properties.status.type !== "idle") return;
+	await handleSessionIdle(runtime, {
+		type: "session.idle",
+		properties: { sessionID: event.properties.sessionID }
+	});
+}
 async function notifyBoundChats(runtime, sessionId, text) {
 	const bindings = await runtime.container.sessionRepo.listBySessionId(sessionId);
 	const chatIds = [...new Set(bindings.map((binding) => binding.chatId))];
@@ -4726,23 +4677,26 @@ function parseSessionActionTarget(data, prefix) {
 }
 //#endregion
 //#region src/bot/handlers/prompt.handler.ts
-var activePromptChats = /* @__PURE__ */ new Set();
 async function executePromptRequest(ctx, dependencies, resolvePrompt) {
 	const copy = await getChatCopy(dependencies.sessionRepo, ctx.chat.id);
-	if (activePromptChats.has(ctx.chat.id)) {
+	const foregroundRequest = dependencies.foregroundSessionTracker.acquire(ctx.chat.id);
+	if (!foregroundRequest) {
 		await ctx.reply(copy.status.alreadyProcessing);
 		return;
 	}
 	let processingMessage = null;
 	let sentTerminalReply = false;
 	try {
-		activePromptChats.add(ctx.chat.id);
 		processingMessage = await ctx.reply(copy.status.processing);
 		const promptInput = await resolvePrompt();
 		const telegramReply = buildTelegramPromptReply(normalizePromptReplyForDisplay((await dependencies.sendPromptUseCase.execute({
 			chatId: ctx.chat.id,
-			text: promptInput.text,
-			files: promptInput.files
+			files: promptInput.files,
+			onExecutionSession: (sessionId) => {
+				foregroundRequest.attachSession(sessionId);
+			},
+			signal: foregroundRequest.signal,
+			text: promptInput.text
 		})).assistantReply, copy, dependencies), copy);
 		try {
 			await ctx.reply(telegramReply.preferred.text, telegramReply.preferred.options);
@@ -4756,7 +4710,7 @@ async function executePromptRequest(ctx, dependencies, resolvePrompt) {
 		await ctx.reply(presentError(error, copy));
 		sentTerminalReply = true;
 	} finally {
-		activePromptChats.delete(ctx.chat.id);
+		foregroundRequest.dispose();
 		if (processingMessage && sentTerminalReply) try {
 			await ctx.api.deleteMessage(ctx.chat.id, processingMessage.message_id);
 		} catch (error) {