@xopcai/xopc 0.0.384 → 0.0.386

package/dist/src/gateway/service/agent-runner.d.ts

@@ -14,6 +14,8 @@ import type { AgentSourceContext, TurnContextRef } from '../../agent/source-cont
 import { SessionInputCoordinator, type ReplaceLatestTurnInput, type SubmitSessionInput } from './session-input-coordinator.js';
 export interface GatewayAgentRunnerOptions {
     validateConnectionResume?: (input: import('../../storage/sqlite/session-input-repository.js').SessionInput) => Promise<boolean>;
+    continueConnection?: (wait: import('@xopcai/gateway-contract').ConnectionWait, idempotencyKey: string) => Promise<void>;
+    cancelConnection?: (wait: import('@xopcai/gateway-contract').ConnectionWait) => void;
     bus: MessageBus;
     sessionIndex: SessionIndex;
     /** Resolved lazily — the runner is constructed before AgentService exists. */

package/dist/src/gateway/service/agent-runner.js

@@ -6,9 +6,11 @@ import { TaskRepository, init_task_repository } from "../../tasks/task-repositor
 import { createClarificationWait, getClarification, getClarificationSnapshot, init_clarification_wait_repository, resolveClarification, supersedeActiveClarification } from "../../storage/sqlite/clarification-wait-repository.js";
 import { init_connection_wait_repository, onConnectionWaitChanged } from "../../storage/sqlite/connection-wait-repository.js";
 import { init_sqlite } from "../../storage/sqlite/index.js";
+import { AgentRunCancelledError } from "../../agent/orchestration/run-termination.js";
 import { isPersonalConversation } from "../../personal-agent/repository.js";
 import { TaskConversationRepository } from "../../tasks/task-conversation-repository.js";
 import { TaskCollaborationRepository } from "../../tasks/task-collaboration-repository.js";
+import { reserveEmbeddedRunCancellation } from "../../agent/embedded/runs.js";
 import { TaskApplicationService } from "../../tasks/task-application-service.js";
 import { EphemeralClarificationWaiter } from "../ephemeral-clarification-waiter.js";
 import { describeActiveExecution } from "./active-execution.js";
@@ -65,10 +67,12 @@ var GatewayAgentRunner = class {
 		});
 		this.inputs = new SessionInputCoordinator({
 			beforeExecute: opts.validateConnectionResume,
+			continueConnection: opts.continueConnection,
+			cancelConnection: opts.cancelConnection,
 			prioritizeInput: (input) => (input.origin.type !== "system" || input.origin.source === "cli") && isPersonalConversation(input.conversationId),
-			interrupt: async (conversationId, runId) => {
+			interrupt: async (conversationId, runId, reason) => {
 				const execution = this.activeExecutionBySession.get(conversationId);
-				if (execution && execution.kind !== "chat") return;
+				if (reason !== "connection_cancel" && execution && execution.kind !== "chat") return;
 				await this.abortAgentRun(runId);
 			},
 			sessionExists: async (conversationId) => Boolean(await opts.sessionIndex.getSessionMetadata(conversationId)),
@@ -187,29 +191,38 @@ var GatewayAgentRunner = class {
 	}
 	async *runAgent(message, channel, chatId, origin, attachments, thinking, runOptions) {
 		const trackedRunId = runOptions?.runId;
+		const cancellation = channel === "webchat" && trackedRunId ? reserveEmbeddedRunCancellation({
+			conversationId: chatId,
+			runId: trackedRunId
+		}) : void 0;
 		if (trackedRunId) {
+			if (channel === "webchat" && !this.runAbortControllers.has(trackedRunId)) this.runAbortControllers.set(trackedRunId, new AbortController());
 			let resolve = () => {};
 			this.runCompletions.set(trackedRunId, new Promise((done) => {
 				resolve = done;
 			}));
 			this.resolveRunCompletions.set(trackedRunId, resolve);
 		}
-		const iter = runGatewayAgent({
-			config: this.opts.getConfig(),
-			agentService: this.opts.getAgentService(),
-			bus: this.opts.bus,
-			runAbortControllers: this.runAbortControllers,
-			activeWebchatRunBySession: this.activeWebchatRunBySession,
-			activeExecutionBySession: this.activeExecutionBySession,
-			sessionIndex: this.opts.sessionIndex,
-			emit: this.opts.emit,
-			publishRealtime: this.opts.publishRealtime,
-			completeRealtimeTopic: this.opts.completeRealtimeTopic
-		}, message, channel, chatId, origin, attachments, thinking, runOptions);
 		try {
-			return yield* iter;
+			return yield* runGatewayAgent({
+				config: this.opts.getConfig(),
+				agentService: this.opts.getAgentService(),
+				bus: this.opts.bus,
+				runAbortControllers: this.runAbortControllers,
+				activeWebchatRunBySession: this.activeWebchatRunBySession,
+				activeExecutionBySession: this.activeExecutionBySession,
+				sessionIndex: this.opts.sessionIndex,
+				emit: this.opts.emit,
+				publishRealtime: this.opts.publishRealtime,
+				completeRealtimeTopic: this.opts.completeRealtimeTopic
+			}, message, channel, chatId, origin, attachments, thinking, cancellation ? {
+				...runOptions,
+				signal: runOptions?.signal ? AbortSignal.any([runOptions.signal, cancellation.signal]) : cancellation.signal
+			} : runOptions);
 		} finally {
+			cancellation?.release();
 			if (trackedRunId) {
+				this.runAbortControllers.delete(trackedRunId);
 				this.resolveRunCompletions.get(trackedRunId)?.();
 				this.resolveRunCompletions.delete(trackedRunId);
 				this.runCompletions.delete(trackedRunId);
@@ -258,9 +271,9 @@ var GatewayAgentRunner = class {
 				data: { runId }
 			}).catch(() => {});
 		}
-		c.abort();
+		c.abort(new AgentRunCancelledError());
 		const { abortEmbeddedRun } = await import("../../agent/embedded/runs.js");
-		await Promise.all(keysToMark.map((conversationId) => abortEmbeddedRun(conversationId).catch(() => false)));
+		await Promise.all(keysToMark.map((conversationId) => abortEmbeddedRun(conversationId, "user_cancelled", runId).catch(() => false)));
 		await completion;
 		return {
 			aborted: true,

package/dist/src/gateway/service/run-gateway-agent.js

@@ -4,12 +4,14 @@ import { init_logger } from "../../utils/logger.js";
 import { parseTurnOutcome } from "../../../packages/gateway-contract/src/turn-outcome.js";
 import { init_src } from "../../../packages/gateway-contract/src/index.js";
 import { init_session_input_repository, listTaskUpdateTriggers } from "../../storage/sqlite/session-input-repository.js";
+import { TaskRunRepository, init_task_run_repository } from "../../tasks/task-run-repository.js";
 import { init_clarification_wait_repository, isClarificationSuspended } from "../../storage/sqlite/clarification-wait-repository.js";
 import { updateInteractionStateFromMessage } from "../../storage/sqlite/interaction-state-repository.js";
 import { getConnectionResumeInput, init_connection_wait_repository, isConnectionSuspended } from "../../storage/sqlite/connection-wait-repository.js";
 import { init_sqlite } from "../../storage/sqlite/index.js";
 import { getConversationRouting } from "../../storage/sqlite/conversation-repository.js";
 import { init_session_key } from "../../routing/session-key.js";
+import { resolveAgentTurnTimeoutMs } from "../../agent/orchestration/run-agent-turn-with-timeout.js";
 import { isPersonalConversation } from "../../personal-agent/repository.js";
 import { resolveExecutionContext } from "../../tasks/execution-context.js";
 import { TaskRunCoordinator } from "../../tasks/task-run-coordinator.js";
@@ -29,6 +31,7 @@ init_clarification_wait_repository();
 init_src();
 init_logger();
 init_session_key();
+init_task_run_repository();
 init_sqlite();
 init_session_input_repository();
 const log = createLogger("Gateway:Service");
@@ -64,7 +67,15 @@ async function* runGatewayAgent(deps, message, channel, chatId, origin, attachme
 		if (!meta) throw new Error("Session not found; submit a start input command first");
 		webchatTranscriptId = meta?.transcriptId;
 		webchatMetadata = meta;
-		runAbortControllers.set(runId, new AbortController());
+		if (!runAbortControllers.has(runId)) runAbortControllers.set(runId, new AbortController());
+		if (runAbortControllers.get(runId).signal.aborted || runOptions?.signal?.aborted || runOptions?.taskRunId && new TaskRunRepository().get(runOptions.taskRunId)?.status === "cancelled") {
+			runAbortControllers.delete(runId);
+			completeRealtimeTopic(`run:${runId}`);
+			return {
+				status: "aborted",
+				summary: "Interrupted before startup"
+			};
+		}
 	}
 	const streamConversationId = webchatConversationId ?? chatId;
 	if (webchatConversationId) {
@@ -89,7 +100,8 @@ async function* runGatewayAgent(deps, message, channel, chatId, origin, attachme
 		taskRun = TaskRunCoordinator.start({
 			runId: runOptions?.taskRunId ?? runId,
 			context: executionContext,
-			fallbackObjective: message
+			fallbackObjective: message,
+			timeoutMs: executionContext.taskId ? resolveAgentTurnTimeoutMs(deps.config, webchatConversationId) : void 0
 		});
 	}
 	const mapper = new ChatStreamMapper({
@@ -156,6 +168,7 @@ async function* runGatewayAgent(deps, message, channel, chatId, origin, attachme
 			const prepared = await agentService.prepareInboundAttachments(conversationId, cappedAttachments);
 			const runAbort = runAbortControllers.get(runId);
 			if (!runAbort) throw new Error("run abort controller missing for webchat");
+			if (runOptions?.taskRunId && new TaskRunRepository().get(runOptions.taskRunId)?.status === "cancelled") runAbort.abort();
 			const mergedSignal = runOptions?.signal ? AbortSignal.any([runOptions.signal, runAbort.signal]) : runAbort.signal;
 			agentService.beginInboundTurn(conversationId);
 			if (!activeWebchatRunBySession.has(conversationId)) {
@@ -192,6 +205,8 @@ async function* runGatewayAgent(deps, message, channel, chatId, origin, attachme
 				});
 				const mappedEvents = (async function* () {
 					for await (const event of eventStream) {
+						if (event.type === "error") streamError ??= String(event.content ?? event.message ?? "Agent run failed");
+						if (event.type === "turn_outcome" && parseTurnOutcome(event.outcome)?.status === "failed") streamError = parseTurnOutcome(event.outcome)?.summary ?? streamError ?? "Agent run failed";
 						if (event.type === "turn_outcome" && parseTurnOutcome(event.outcome)?.summary === "aborted") embeddedAborted = true;
 						yield* mapper.map(event);
 					}
@@ -201,16 +216,16 @@ async function* runGatewayAgent(deps, message, channel, chatId, origin, attachme
 				const clarificationSuspended = isClarificationSuspended(conversationId, runId);
 				const suspended = connectionSuspended || clarificationSuspended;
 				const cancelled = mergedSignal.aborted || embeddedAborted;
-				const endStatus = cancelled ? "cancelled" : suspended ? "suspended" : "success";
-				const endSummary = cancelled ? "Interrupted" : connectionSuspended ? "Waiting for connection" : clarificationSuspended ? "Waiting for user input" : "Message processed successfully";
-				taskRunStatus = cancelled ? "cancelled" : "succeeded";
+				const endStatus = cancelled ? "cancelled" : suspended ? "suspended" : streamError ? "error" : "success";
+				const endSummary = cancelled ? "Interrupted" : connectionSuspended ? "Waiting for connection" : clarificationSuspended ? "Waiting for user input" : streamError ?? "Message processed successfully";
+				taskRunStatus = cancelled ? "cancelled" : streamError ? "failed" : "succeeded";
 				terminalStatus = endStatus;
 				taskRunSummary = endSummary;
 				yield* emitAndYield(mapper.end(endStatus, endSummary));
 				completeRealtimeTopic(`run:${runId}`);
 				runTopicCompleted = true;
 				return {
-					status: cancelled ? "aborted" : suspended ? "suspended" : "ok",
+					status: cancelled ? "aborted" : suspended ? "suspended" : streamError ? "error" : "ok",
 					summary: endSummary
 				};
 			} catch (error) {

package/dist/src/gateway/service/session-input-coordinator.d.ts

@@ -1,4 +1,5 @@
 import type { TurnOrigin } from '@xopcai/endpoint-tools-protocol';
+import type { ConnectionWait } from '@xopcai/gateway-contract';
 import { type SessionInput } from '../../storage/sqlite/session-input-repository.js';
 import type { UserTurnAttachment } from '../user-turn-input.js';
 import { type AgentSourceContext, type TurnContextRef } from '../../agent/source-context/types.js';
@@ -26,12 +27,15 @@ export declare class SessionInputCoordinator {
     private readonly resumeAfter;
     private readonly draining;
     private readonly submissionTails;
+    private readonly pendingConnectionStops;
     constructor(deps: {
         prioritizeInput?: (input: SubmitSessionInput) => boolean;
-        interrupt?: (conversationId: string, runId: string) => Promise<void>;
+        interrupt?: (conversationId: string, runId: string, reason?: 'connection_cancel') => Promise<void>;
         coalesceWindowMs?: number;
         onInputReceived?: (conversationId: string) => void;
         beforeExecute?: (input: SessionInput) => Promise<boolean>;
+        continueConnection?: (wait: ConnectionWait, idempotencyKey: string) => Promise<void>;
+        cancelConnection?: (wait: ConnectionWait) => void;
         sessionExists: (conversationId: string) => Promise<boolean>;
         execute: (input: {
             inputReceivedAtMs?: number;
@@ -54,7 +58,9 @@ export declare class SessionInputCoordinator {
     });
     isAcceptingInput(conversationId: string): boolean;
     snapshot(conversationId: string): SessionInputState;
+    private connectionTarget;
     prepareInput(input: SubmitSessionInput): Promise<{
+        payload?: import("../../storage/sqlite/session-input-repository.js").SessionInputPayload;
         status: "queued";
         requestedDelivery: SessionInputDelivery;
         effectiveDelivery: "next";
@@ -98,6 +104,9 @@ export declare class SessionInputCoordinator {
     }>;
     private submitLocked;
     drain(conversationId: string): Promise<void>;
+    private requestConnectionStop;
+    private completeConnectionCancellation;
+    private executeConnectionControl;
     update(conversationId: string, id: string, body: {
         version: number;
         content?: string;

package/dist/src/gateway/service/session-input-coordinator.js

@@ -1,10 +1,16 @@
 import { createLogger } from "../../utils/logger/index.js";
 import { init_logger } from "../../utils/logger.js";
+import { getSqliteDatabase, init_transaction, runSqliteWriteTransaction } from "../../storage/sqlite/transaction.js";
+import { init_session_instance_repository, readCurrentTranscriptId } from "../../storage/sqlite/session-instance-repository.js";
 import { SessionInstanceChangedError, cancelQueuedSessionInput, claimNextSessionInput, findSessionInput, findSessionInputByRunId, finishSessionInputRun, getSessionInputById, getSessionInputState, init_session_input_repository, insertSessionInput, mutateQueuedSessionInput, recoverSessionInputState, setSessionInputStatus } from "../../storage/sqlite/session-input-repository.js";
-import { consumeClarificationResume, init_clarification_wait_repository, supersedeActiveClarification } from "../../storage/sqlite/clarification-wait-repository.js";
+import { TaskRunRepository, init_task_run_repository } from "../../tasks/task-run-repository.js";
+import { consumeClarificationResume, getActiveClarification, init_clarification_wait_repository, supersedeActiveClarification } from "../../storage/sqlite/clarification-wait-repository.js";
 import { replaceLatestSessionTurnAndQueueInput, validateLatestSessionTurnTarget } from "../../storage/sqlite/session-turn-replace-repository.js";
-import { cancelConnectionObjective, consumeConnectionResume, init_connection_wait_repository, invalidateConnectionResumeIntent, publishConnectionWait } from "../../storage/sqlite/connection-wait-repository.js";
+import { cancelConnectionObjective, consumeConnectionResume, getActiveConnectionWait, getConnectionWait, hasPendingConnectionMessages, init_connection_wait_repository, interruptedConnectionMessage, publishConnectionWait, reconcileConnectionWaits } from "../../storage/sqlite/connection-wait-repository.js";
+import { appendTranscriptEntry, init_transcript_repository } from "../../storage/sqlite/transcript-repository.js";
 import { init_sqlite } from "../../storage/sqlite/index.js";
+import { emitSessionTranscriptUpdate } from "../../session/transcript-events.js";
+import { TaskApplicationService } from "../../tasks/task-application-service.js";
 import { summarizeSourceContext } from "../../agent/source-context/types.js";
 import { injectSourceContextsIntoUserMessage } from "../../agent/source-context/injector.js";
 import { deleteMediaUrisNoLongerReferenced } from "../../media/session-references.js";
@@ -14,11 +20,37 @@ import { isDeepStrictEqual } from "node:util";
 //#region src/gateway/service/session-input-coordinator.ts
 init_session_input_repository();
 init_connection_wait_repository();
+init_transaction();
+init_transcript_repository();
+init_session_instance_repository();
 init_clarification_wait_repository();
 init_sqlite();
 init_logger();
+init_task_run_repository();
 const log = createLogger("SessionInputCoordinator");
 const MAX_PENDING_INPUTS = 10;
+function connectionControl(input, wait) {
+	if (input.attachments?.length || input.contextRefs?.length || input.sourceContexts?.some((source) => source.kind !== "device_context") || input.origin.type === "system" && input.origin.source !== "cli") return void 0;
+	const text = input.content.trim().toLowerCase().replace(/[。.!！?？]+$/u, "").trim();
+	if (/^(?:继续|继续看下|继续看看|继续这个目标|继续原目标|continue|resume)$/u.test(text)) {
+		if (text !== "继续原目标" && (hasPendingConnectionMessages(wait) || getActiveClarification(wait.conversationId))) return void 0;
+		return "continue";
+	}
+	if (/^(?:取消这个目标|取消原目标|取消当前目标|cancel this objective|cancel the original objective)$/u.test(text)) return "cancel";
+}
+function connectionInputPayload(wait, control) {
+	if (!wait) return void 0;
+	if (control) return {
+		waitId: wait.id,
+		objectiveRevision: wait.objectiveRevision,
+		connectionAction: control
+	};
+	if (wait.status !== "closed") return {
+		waitId: wait.id,
+		objectiveRevision: wait.objectiveRevision,
+		connectionBarrier: true
+	};
+}
 function sameAppContext(input, existing) {
 	const identity = (sources) => sources?.filter((source) => source.kind === "app_context").map((source) => ({
 		snapshot: source.appContext,
@@ -52,6 +84,7 @@ var SessionInputCoordinator = class {
 	resumeAfter = /* @__PURE__ */ new Map();
 	draining = /* @__PURE__ */ new Set();
 	submissionTails = /* @__PURE__ */ new Map();
+	pendingConnectionStops = /* @__PURE__ */ new Set();
 	constructor(deps) {
 		this.deps = deps;
 	}
@@ -61,9 +94,15 @@ var SessionInputCoordinator = class {
 	snapshot(conversationId) {
 		return getSessionInputState(conversationId);
 	}
+	connectionTarget(conversationId, runtime = this.snapshot(conversationId)) {
+		const active = runtime.activeInputId ? getSessionInputById(conversationId, runtime.activeInputId) : void 0;
+		return getActiveConnectionWait(conversationId) ?? (active?.kind === "connection_resume" && active.payload ? getConnectionWait(active.payload.waitId) : void 0);
+	}
 	async prepareInput(input) {
 		const attachments = await this.deps.prepareAttachments(input.conversationId, input.attachments);
 		const contexts = fitSourceContextsToBudget([...await this.deps.prepareContexts(input.conversationId, input.contextRefs) ?? [], ...input.sourceContexts ?? []]);
+		const wait = this.connectionTarget(input.conversationId);
+		const payload = connectionInputPayload(wait, wait?.principalId === "local-owner" ? connectionControl(input, wait) : void 0);
 		return {
 			status: "queued",
 			requestedDelivery: input.delivery,
@@ -71,10 +110,11 @@ var SessionInputCoordinator = class {
 			content: input.content.trim(),
 			attachments,
 			contextRefs: contexts.map(summarizeSourceContext),
-			interruptRequested: input.interrupt !== false && this.deps.prioritizeInput?.(input) === true,
+			interruptRequested: !wait && input.interrupt !== false && this.deps.prioritizeInput?.(input) === true,
 			contextSnapshots: contexts,
 			thinking: input.thinking,
-			origin: input.origin
+			origin: input.origin,
+			...payload ? { payload } : {}
 		};
 	}
 	async dispatchAcceptedInput(conversationId, inputId) {
@@ -84,6 +124,11 @@ var SessionInputCoordinator = class {
 			const row = getSessionInputById(conversationId, inputId);
 			const state = this.snapshot(input.conversationId);
 			if (!row || row.status !== "queued") return;
+			if (row.payload?.connectionAction === "cancel") this.completeConnectionCancellation(row);
+			if (row.payload?.connectionAction || this.connectionTarget(row.conversationId, state)) {
+				this.requestConnectionStop(row);
+				return;
+			}
 			if (row.interruptRequested) {
 				this.prioritizeAcceptedInput(row, state);
 				return;
@@ -158,6 +203,7 @@ var SessionInputCoordinator = class {
 			const remaining = (this.pendingSubmissions.get(conversationId) ?? 1) - 1;
 			if (remaining) this.pendingSubmissions.set(conversationId, remaining);
 			else this.pendingSubmissions.delete(conversationId);
+			this.drain(conversationId);
 		}
 	}
 	async submit(input) {
@@ -303,27 +349,36 @@ var SessionInputCoordinator = class {
 			};
 		}
 		const runtime = this.snapshot(conversationId);
-		const priority = input.interrupt !== false && this.deps.prioritizeInput?.(input) === true;
-		const canSteer = !priority && input.delivery === "steer" && runtime.activeRunId !== void 0 && !attachments?.length && canSteerContexts(runtime, input.origin, sourceContexts);
+		const wait = this.connectionTarget(conversationId, runtime);
+		const control = wait?.principalId === "local-owner" ? connectionControl(input, wait) : void 0;
+		const payload = connectionInputPayload(wait, control);
+		const priority = !wait && input.interrupt !== false && this.deps.prioritizeInput?.(input) === true;
+		const canSteer = !wait && !priority && input.delivery === "steer" && runtime.activeRunId !== void 0 && !attachments?.length && canSteerContexts(runtime, input.origin, sourceContexts);
 		const effectiveDelivery = canSteer ? "steer" : "next";
-		const row = insertSessionInput({
-			expectedTranscriptId: input.expectedTranscriptId,
-			id: crypto.randomUUID(),
-			conversationId,
-			clientMessageId,
-			requestedDelivery: input.delivery,
-			interruptRequested: priority,
-			effectiveDelivery,
-			status: canSteer ? "injecting" : "queued",
-			content,
-			attachments,
-			contextRefs: sourceContexts?.map(summarizeSourceContext),
-			contextSnapshots: sourceContexts,
-			thinking: input.thinking,
-			origin: input.origin,
-			targetRunId: canSteer ? runtime.activeRunId : void 0
+		const row = runSqliteWriteTransaction(() => {
+			const row = insertSessionInput({
+				expectedTranscriptId: input.expectedTranscriptId ?? (payload ? wait?.transcriptId : void 0),
+				id: crypto.randomUUID(),
+				conversationId,
+				clientMessageId,
+				requestedDelivery: input.delivery,
+				interruptRequested: priority,
+				effectiveDelivery,
+				status: canSteer ? "injecting" : "queued",
+				content,
+				attachments,
+				contextRefs: sourceContexts?.map(summarizeSourceContext),
+				contextSnapshots: sourceContexts,
+				thinking: input.thinking,
+				origin: input.origin,
+				targetRunId: canSteer ? runtime.activeRunId : void 0,
+				...payload ? { payload } : {}
+			});
+			if (control === "cancel") cancelConnectionObjective(conversationId, wait?.id, wait?.objectiveRevision);
+			return row;
 		});
-		invalidateConnectionResumeIntent(conversationId);
+		if (control === "cancel") this.completeConnectionCancellation(row);
+		this.requestConnectionStop(row);
 		supersedeActiveClarification(conversationId);
 		if (priority) {
 			this.prioritizeAcceptedInput(row, runtime);
@@ -364,6 +419,7 @@ var SessionInputCoordinator = class {
 		this.draining.add(conversationId);
 		try {
 			while (true) {
+				if (this.isAcceptingInput(conversationId)) return;
 				const delay = (this.resumeAfter.get(conversationId) ?? 0) - Date.now();
 				if (delay > 0) {
 					await new Promise((resolve) => setTimeout(resolve, delay));
@@ -375,7 +431,15 @@ var SessionInputCoordinator = class {
 				if (!input) return;
 				let allowed;
 				try {
-					allowed = (!this.deps.beforeExecute || await this.deps.beforeExecute(input)) && consumeConnectionResume(input) && consumeClarificationResume(input);
+					allowed = !this.deps.beforeExecute || await this.deps.beforeExecute(input);
+					const wait = input.kind === "connection_resume" && input.payload ? getConnectionWait(input.payload.waitId) : void 0;
+					if (allowed && wait?.status === "queued" && wait.queuedInputId === input.id && (this.isAcceptingInput(conversationId) || hasPendingConnectionMessages(wait, true))) {
+						finishSessionInputRun(conversationId, runId, "interrupted");
+						setSessionInputStatus(input.id, "queued");
+						this.publish(conversationId);
+						continue;
+					}
+					allowed = allowed && consumeConnectionResume(input) && consumeClarificationResume(input);
 				} catch (err) {
 					log.warn({
 						err,
@@ -384,6 +448,7 @@ var SessionInputCoordinator = class {
 						inputId: input.id
 					}, "Session input preflight failed");
 					finishSessionInputRun(conversationId, runId, "failed", "Input preflight failed");
+					if (input.kind === "connection_resume") reconcileConnectionWaits();
 					this.publish(conversationId);
 					continue;
 				}
@@ -396,7 +461,7 @@ var SessionInputCoordinator = class {
 				this.publish(conversationId);
 				let result;
 				try {
-					result = await this.deps.execute({
+					result = input.payload?.connectionAction ? await this.executeConnectionControl(input) : await this.deps.execute({
 						inputReceivedAtMs: input.createdAtMs,
 						runId,
 						taskRunId: input.taskRunId,
@@ -419,7 +484,37 @@ var SessionInputCoordinator = class {
 						inputId: input.id
 					}, "Session input execution failed");
 				}
-				const terminal = result.status === "suspended" ? "suspended" : result.status === "ok" ? "completed" : result.status === "aborted" ? "cancelled" : "failed";
+				const cancelledWait = input.kind === "connection_resume" && input.payload ? getConnectionWait(input.payload.waitId) : void 0;
+				const cancelled = cancelledWait?.resolution === "cancelled" && cancelledWait.objectiveRevision === input.payload?.objectiveRevision;
+				if (cancelled && input.taskRunId) {
+					const run = new TaskRunRepository().get(input.taskRunId);
+					if (run && [
+						"queued",
+						"running",
+						"waiting",
+						"verifying"
+					].includes(run.status)) new TaskApplicationService().completeRun({
+						runId: run.id,
+						expectedRunVersion: run.version,
+						actor: { kind: "user" },
+						terminalCode: "cancelled_by_user",
+						suppressAttention: true,
+						receipt: {
+							status: "cancelled",
+							summary: "Connection objective cancelled",
+							changes: [],
+							evidence: [],
+							verification: {
+								status: "unverified",
+								checks: []
+							},
+							remainingWork: [],
+							needsUser: false,
+							completionVerdict: "not_achieved"
+						}
+					});
+				}
+				const terminal = cancelled ? "cancelled" : result.status === "suspended" ? "suspended" : result.status === "ok" ? "completed" : result.status === "aborted" ? "cancelled" : "failed";
 				finishSessionInputRun(conversationId, runId, terminal, terminal === "failed" ? result.summary : void 0);
 				this.publish(conversationId);
 			}
@@ -427,6 +522,94 @@ var SessionInputCoordinator = class {
 			this.draining.delete(conversationId);
 		}
 	}
+	requestConnectionStop(input) {
+		const target = input.payload;
+		if (target?.connectionAction !== "cancel" || !this.deps.interrupt) return;
+		const wait = getConnectionWait(target.waitId);
+		if (!wait || wait.resolution !== "cancelled" || wait.objectiveRevision !== target.objectiveRevision || wait.transcriptId !== input.expectedTranscriptId) return;
+		const runtime = this.snapshot(input.conversationId);
+		const active = runtime.activeInputId ? getSessionInputById(input.conversationId, runtime.activeInputId) : void 0;
+		if (!runtime.activeRunId || active?.kind !== "connection_resume" || !active.payload) return;
+		const sameVersion = active.payload.waitId === target.waitId && active.payload.objectiveRevision === target.objectiveRevision;
+		const parent = getConnectionWait(active.payload.waitId);
+		const sameExecution = wait.originInputId === active.id && parent?.objectiveId === wait.objectiveId;
+		if (!sameVersion && !sameExecution || this.pendingConnectionStops.has(runtime.activeRunId)) return;
+		const runId = runtime.activeRunId;
+		this.pendingConnectionStops.add(runId);
+		this.deps.emit("session.input-interrupt", {
+			conversationId: input.conversationId,
+			runId,
+			inputId: input.id
+		});
+		this.deps.interrupt(input.conversationId, runId, "connection_cancel").catch((err) => {
+			log.warn({
+				err,
+				conversationId: input.conversationId,
+				runId
+			}, "Connection cancellation saved; execution stop was not confirmed");
+		}).finally(() => {
+			this.pendingConnectionStops.delete(runId);
+		});
+	}
+	completeConnectionCancellation(input) {
+		const wait = input.payload ? getConnectionWait(input.payload.waitId) : void 0;
+		if (wait?.objectiveRevision !== input.payload?.objectiveRevision || wait?.resolution !== "cancelled") return;
+		try {
+			this.deps.cancelConnection?.(wait);
+		} catch (err) {
+			log.warn({
+				err,
+				conversationId: input.conversationId,
+				waitId: wait.id
+			}, "Connection cancellation saved; domain cleanup will retry with its control");
+		}
+	}
+	async executeConnectionControl(input) {
+		const target = input.payload;
+		if (!target?.connectionAction) throw new Error("Connection control is required");
+		let wait = getConnectionWait(target.waitId);
+		if (target.connectionAction === "cancel" && wait?.objectiveRevision === target.objectiveRevision) this.deps.cancelConnection?.(wait);
+		if (target.connectionAction === "continue" && wait?.objectiveRevision === target.objectiveRevision) try {
+			await this.deps.continueConnection?.(wait, `connection-control:${input.id}`);
+		} catch (err) {
+			log.warn({
+				err,
+				conversationId: input.conversationId,
+				waitId: target.waitId
+			}, "Connection control preserved for current status feedback");
+		}
+		wait = getConnectionWait(target.waitId);
+		const zh = /[\u3400-\u9fff]/u.test(input.content);
+		const summary = !wait || wait.objectiveRevision !== target.objectiveRevision ? zh ? "原目标已发生变化，请查看当前目标状态。" : "The original objective changed. Check the current objective status." : target.connectionAction === "cancel" ? zh ? "已取消原目标。" : "The original objective was cancelled." : interruptedConnectionMessage(wait) ? zh ? "原目标已保留。请重新发送重启时中断的补充要求，或移除中断的消息后继续。" : "The original objective is saved. Resend the interrupted message or remove it before continuing." : wait.resolution === "cancelled" ? zh ? "原目标已取消。" : "The original objective was cancelled." : wait.status === "closed" ? zh ? "原目标已交给执行流程，无需重复继续。" : "The original objective has already been handed to execution. No additional continuation is needed." : wait.status === "queued" ? zh ? "原目标已准备好，正在等待执行，无需重复继续。" : "The original objective is queued. No additional continuation is needed." : wait.intent ? zh ? "原目标已保留，完成连接和能力检查后会自动继续。" : "The original objective is saved and will continue automatically after connection and capability checks." : zh ? "原目标已保留，请查看连接操作区完成所需操作。" : "The original objective is saved. Complete the required action in the connection panel.";
+		const persisted = runSqliteWriteTransaction(() => {
+			const runtime = this.snapshot(input.conversationId);
+			if (runtime.activeInputId !== input.id || runtime.activeRunId !== input.runId || readCurrentTranscriptId(getSqliteDatabase(), input.conversationId) !== input.expectedTranscriptId) return false;
+			appendTranscriptEntry(input.conversationId, {
+				role: "user",
+				content: input.content,
+				timestamp: input.createdAtMs
+			});
+			appendTranscriptEntry(input.conversationId, {
+				role: "custom",
+				customType: "connection_control_status",
+				content: summary,
+				details: {
+					inputId: input.id,
+					waitId: target.waitId,
+					objectiveRevision: target.objectiveRevision
+				},
+				display: true,
+				timestamp: Date.now()
+			});
+			finishSessionInputRun(input.conversationId, input.runId, "completed");
+			return true;
+		});
+		if (persisted) emitSessionTranscriptUpdate({ conversationId: input.conversationId });
+		return {
+			status: persisted ? "ok" : "aborted",
+			summary: persisted ? summary : ""
+		};
+	}
 	async update(conversationId, id, body) {
 		const attachments = body.attachments === void 0 ? void 0 : await this.deps.prepareAttachments(conversationId, body.attachments);
 		let sourceContexts;
@@ -463,6 +646,10 @@ var SessionInputCoordinator = class {
 	}
 	remove(conversationId, id, version) {
 		const ok = cancelQueuedSessionInput(conversationId, id, version);
+		if (ok) {
+			publishConnectionWait(conversationId);
+			this.drain(conversationId);
+		}
 		return {
 			ok,
 			state: ok ? this.publish(conversationId) : this.snapshot(conversationId)
@@ -478,7 +665,9 @@ var SessionInputCoordinator = class {
 		}
 	}
 	recover() {
-		for (const conversationId of recoverSessionInputState()) {
+		const interrupted = recoverSessionInputState();
+		new TaskRunRepository().reconcileCancelledRuns();
+		for (const conversationId of new Set([...interrupted, ...reconcileConnectionWaits(true)])) {
 			this.publish(conversationId);
 			this.drain(conversationId);
 		}

package/dist/src/gateway/service.d.ts

@@ -155,6 +155,7 @@ export declare class GatewayService {
     }>;
     withSessionInputSubmission<T>(conversationId: string, operation: () => Promise<T>): Promise<T>;
     prepareSessionCommandInput(input: Parameters<GatewayAgentRunner['inputs']['prepareInput']>[0]): Promise<{
+        payload?: import("../storage/sqlite/session-input-repository.js").SessionInputPayload;
         status: "queued";
         requestedDelivery: import("../storage/sqlite/session-input-repository.js").SessionInputDelivery;
         effectiveDelivery: "next";

package/dist/src/gateway/service.js

@@ -44,6 +44,7 @@ import { DomainOutboxDispatcher } from "../infra/domain-outbox-dispatcher.js";
 import { ProjectService } from "../projects/project-service.js";
 import { resolveProjectAgentId } from "../projects/project-agent.js";
 import "../projects/index.js";
+import { onTaskResultQueued } from "../tasks/task-result-delivery-repository.js";
 import { runMemoryMaintenance } from "../memory-maintenance/service.js";
 import "../memory-maintenance/index.js";
 import { RealtimeExtensionBrowserProvider } from "../browser/providers/realtime-extension.js";
@@ -52,7 +53,6 @@ import { buildNoteAgentContext } from "../notes/agent-context.js";
 import { NotesStore } from "../notes/store.js";
 import { NotesService } from "../notes/service.js";
 import { LocalAppService } from "../local-apps/service.js";
-import { onTaskResultQueued } from "../tasks/task-result-delivery-repository.js";
 import { TaskApplicationService } from "../tasks/task-application-service.js";
 import { AutomationService } from "../automations/service/automation-service.js";
 import { TaskSignalService } from "../tasks/task-signal-service.js";
@@ -73,12 +73,12 @@ import "../infra/bus/index.js";
 import { collectMediaUrisFromMessages, deleteMediaUris } from "../media/session-references.js";
 import { AgentService } from "../agent/service.js";
 import { bootstrapApplicationStateSync } from "../bootstrap/application-state.js";
-import { ChatPreviewService } from "../chat-previews/service.js";
-import "../chat-previews/index.js";
-import "../config/index.js";
 import { setPairingBroadcastSink } from "../channels/pairing/pairing-events.js";
 import { registerClarificationChannelRuntime } from "./clarify-runtime.js";
 import { ChannelManager } from "../channels/manager.js";
+import { ChatPreviewService } from "../chat-previews/service.js";
+import "../chat-previews/index.js";
+import "../config/index.js";
 import { ManagedComposioEventPoller } from "../connectors/composio-managed-events.js";
 import { startConnectedKnowledgeCoordinator } from "../knowledge/coordinator.js";
 import "../knowledge/index.js";
@@ -515,6 +515,8 @@ var GatewayService = class {
 		});
 		this.chatPreviews = new ChatPreviewService({ localApps: this.localApps });
 		this.agentRunner = new GatewayAgentRunner({
+			continueConnection: (wait, idempotencyKey) => this.connectionRecovery.continueObjective(wait, idempotencyKey),
+			cancelConnection: (wait) => this.connectionRecovery.cancelObjective(wait),
 			validateConnectionResume: async (input) => {
 				for (const source of input.contextSnapshots ?? []) if (source.kind === "app_context") await checkAppContextAccess(source, this.appContextDispatcher(), this.auth);
 				return this.connectionRecovery.preflight(input);