@genesislcap/ai-assistant 14.452.1 → 14.453.0

package/dist/dts/main/main.template.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"main.template.d.ts","sourceRoot":"","sources":["../../../src/main/main.template.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AASH,OAAO,EAA2B,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAC9E,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,QAAQ,CAAC;AAwIpD,gBAAgB;AAChB,eAAO,MAAM,6BAA6B,GACxC,oBAAoB,MAAM,KACzB,YAAY,CAAC,qBAAqB,CA8hBpC,CAAC"}
+{"version":3,"file":"main.template.d.ts","sourceRoot":"","sources":["../../../src/main/main.template.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AASH,OAAO,EAAuC,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAC1F,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,QAAQ,CAAC;AAwIpD,gBAAgB;AAChB,eAAO,MAAM,6BAA6B,GACxC,oBAAoB,MAAM,KACzB,YAAY,CAAC,qBAAqB,CAijBpC,CAAC"}

package/dist/dts/main/main.types.d.ts

@@ -1,9 +1,13 @@
 /**
  * State of the AI assistant component.
  *
+ * `cancelling` is a refinement of `loading`: a stop was requested but the turn
+ * is still winding down (e.g. a tool mid-execution finishing). It is "busy"
+ * like `loading` — use the host's `busy` getter for "is a turn active" gates.
+ *
  * @beta
  */
-export type AiAssistantState = 'idle' | 'loading' | 'error';
+export type AiAssistantState = 'idle' | 'loading' | 'cancelling' | 'error';
 /**
  * Controls the pop-out button shown in the assistant header.
  * - `"expand"` — assistant is embedded in the bubble dialog; button expands it to a layout panel.

package/dist/dts/main/main.types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"main.types.d.ts","sourceRoot":"","sources":["../../../src/main/main.types.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,MAAM,MAAM,gBAAgB,GAAG,MAAM,GAAG,SAAS,GAAG,OAAO,CAAC;AAE5D;;;;;;GAMG;AACH,MAAM,MAAM,UAAU,GAAG,QAAQ,GAAG,UAAU,CAAC;AAE/C,YAAY,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAElE;;;;;;;;GAQG;AACH,MAAM,WAAW,mBAAmB;IAClC,EAAE,EAAE,OAAO,CAAC;IACZ,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB;AAED;;;;GAIG;AACH,MAAM,MAAM,gBAAgB,GACxB;IAAE,MAAM,EAAE,MAAM,CAAA;CAAE,GAClB;IAAE,MAAM,EAAE,SAAS,CAAA;CAAE,GACrB;IAAE,MAAM,EAAE,QAAQ,CAAC;IAAC,WAAW,EAAE,MAAM,EAAE,CAAA;CAAE,GAC3C;IAAE,MAAM,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC;AAEzC;;;;GAIG;AACH,MAAM,WAAW,uBAAuB;IACtC,uDAAuD;IACvD,KAAK,EAAE,MAAM,CAAC;IACd,0DAA0D;IAC1D,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;;;;GAKG;AACH,eAAO,MAAM,cAAc;;;;;;;;;CASwB,CAAC;AAEpD;;;;GAIG;AACH,MAAM,MAAM,oBAAoB,GAAG,MAAM,OAAO,cAAc,CAAC;AAE/D;;;;GAIG;AACH,eAAO,MAAM,cAAc,EAAkC,oBAAoB,EAAE,CAAC"}
+{"version":3,"file":"main.types.d.ts","sourceRoot":"","sources":["../../../src/main/main.types.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,MAAM,MAAM,gBAAgB,GAAG,MAAM,GAAG,SAAS,GAAG,YAAY,GAAG,OAAO,CAAC;AAE3E;;;;;;GAMG;AACH,MAAM,MAAM,UAAU,GAAG,QAAQ,GAAG,UAAU,CAAC;AAE/C,YAAY,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAElE;;;;;;;;GAQG;AACH,MAAM,WAAW,mBAAmB;IAClC,EAAE,EAAE,OAAO,CAAC;IACZ,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB;AAED;;;;GAIG;AACH,MAAM,MAAM,gBAAgB,GACxB;IAAE,MAAM,EAAE,MAAM,CAAA;CAAE,GAClB;IAAE,MAAM,EAAE,SAAS,CAAA;CAAE,GACrB;IAAE,MAAM,EAAE,QAAQ,CAAC;IAAC,WAAW,EAAE,MAAM,EAAE,CAAA;CAAE,GAC3C;IAAE,MAAM,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC;AAEzC;;;;GAIG;AACH,MAAM,WAAW,uBAAuB;IACtC,uDAAuD;IACvD,KAAK,EAAE,MAAM,CAAC;IACd,0DAA0D;IAC1D,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;;;;GAKG;AACH,eAAO,MAAM,cAAc;;;;;;;;;CASwB,CAAC;AAEpD;;;;GAIG;AACH,MAAM,MAAM,oBAAoB,GAAG,MAAM,OAAO,cAAc,CAAC;AAE/D;;;;GAIG;AACH,eAAO,MAAM,cAAc,EAAkC,oBAAoB,EAAE,CAAC"}

package/dist/esm/components/chat-driver/chat-driver.js

@@ -114,6 +114,24 @@ export class ChatDriver extends EventTarget {
         this.turnSnapshots = [];
         /** Monotonic counter that survives agent swaps — useful for cross-referencing with history. */
         this.globalTurnIndex = 0;
+        /**
+         * Aborted by `dispose()` on driver teardown (e.g. an agent-config swap).
+         * Threaded into every provider call as `ChatRequestOptions.signal`, so a
+         * disposed driver's in-flight LLM request is cancelled instead of running on
+         * to completion or the transport timeout. Also passed to prompt/tool
+         * factories via `SystemPromptContext.signal`.
+         */
+        this.lifecycleController = new AbortController();
+        /**
+         * Per-turn abort controller, reset at the start of every turn by `beginTurn`.
+         * Aborted by `cancel()` (user stop) and chained to `lifecycleController` so a
+         * driver dispose also ends the current turn. Its signal — not the lifecycle
+         * one — is what reaches the provider call, so a turn can be cancelled without
+         * bricking the driver for the next message.
+         */
+        this.turnController = new AbortController();
+        /** True when the current turn was stopped via `cancel()` (vs a dispose). Drives the "Stopped." marker. */
+        this.turnCancelled = false;
         /**
          * Caches validated provider lookups per name within the current agent. Cleared
          * by `applyAgent` so each new agent's static/function-resolved names are
@@ -141,6 +159,65 @@ export class ChatDriver extends EventTarget {
         this.maxFoldOperations = maxFoldOperations;
         this.maxTurnSnapshots = maxTurnSnapshots;
     }
+    /**
+     * Tear down the driver: aborts the lifecycle signal so any in-flight provider
+     * request (and prompt/tool factories awaiting it) cancels instead of running
+     * on to completion or the transport timeout. Called by the host on driver
+     * swap and by `OrchestratingDriver.dispose()`. Idempotent.
+     */
+    dispose() {
+        this.lifecycleController.abort(new DOMException('AI assistant driver disposed', 'AbortError'));
+    }
+    /**
+     * Stop the current turn (user "stop" button). Aborts the in-flight provider
+     * request immediately; if a tool is mid-execution it runs to completion and
+     * the loop bails at the next boundary (tools are atomic). No-op when idle.
+     * The driver stays usable for the next message.
+     */
+    cancel() {
+        if (!this.busy)
+            return;
+        this.turnCancelled = true;
+        this.turnController.abort(new DOMException('Cancelled by user', 'AbortError'));
+    }
+    /**
+     * Start a fresh per-turn abort scope. Chains `lifecycleController` into the
+     * new `turnController` so a dispose mid-turn also aborts the request.
+     */
+    beginTurn() {
+        this.turnCancelled = false;
+        this.turnController = new AbortController();
+        const lifecycle = this.lifecycleController.signal;
+        if (lifecycle.aborted) {
+            this.turnController.abort(lifecycle.reason);
+            this.unlinkLifecycleFromTurn = undefined;
+            return;
+        }
+        const onDispose = () => this.turnController.abort(lifecycle.reason);
+        lifecycle.addEventListener('abort', onDispose, { once: true });
+        this.unlinkLifecycleFromTurn = () => lifecycle.removeEventListener('abort', onDispose);
+    }
+    /** Detach the lifecycle→turn link so a long-lived lifecycle signal doesn't accumulate listeners. */
+    endTurn() {
+        var _a;
+        (_a = this.unlinkLifecycleFromTurn) === null || _a === void 0 ? void 0 : _a.call(this);
+        this.unlinkLifecycleFromTurn = undefined;
+    }
+    /**
+     * Finish a turn whose signal aborted. A user cancel adds a subtle "Stopped."
+     * marker; a dispose-driven abort stops quietly (the widget is gone and the
+     * cached history would otherwise gain a stray marker on remount).
+     */
+    completeAbortedTurn() {
+        if (this.turnCancelled) {
+            logger.warn('ChatDriver: turn cancelled by user');
+            this.appendToHistory({ role: 'system-event', content: 'Stopped.' });
+        }
+        else {
+            logger.warn('ChatDriver: turn aborted (driver disposed)');
+        }
+        return { reason: 'done' };
+    }
     /**
      * Swap in a new agent's configuration. Called by OrchestratingDriver before
      * each specialist turn so the shared driver runs with the right tools and prompt.
@@ -602,6 +679,7 @@ export class ChatDriver extends EventTarget {
             if (this.busy || (!userInput.trim() && !(attachments === null || attachments === void 0 ? void 0 : attachments.length)))
                 return { reason: 'done' };
             this.busy = true;
+            this.beginTurn();
             this.subAgentCompletion = undefined;
             this.subAgentFailure = undefined;
             this.agentReleaseRequested = false;
@@ -637,6 +715,7 @@ export class ChatDriver extends EventTarget {
                     durationMs: Date.now() - this.turnStartedAt,
                 });
                 this.busy = false;
+                this.endTurn();
                 agenticActivityBus.publish('tool-loop-end', undefined);
             }
         });
@@ -708,6 +787,16 @@ export class ChatDriver extends EventTarget {
             // Mark before the first turn so the child forces tool use and reports a
             // typed failure (rather than user-facing text) if it never completes.
             child.markAsSubAgent();
+            // Propagate disposal: if this (parent) driver is torn down while the
+            // sub-agent is mid-flight, dispose the child too so its in-flight request
+            // aborts. Detached in the `finally` below once the sub-agent completes.
+            const disposeChild = () => child.dispose();
+            if (this.lifecycleController.signal.aborted) {
+                disposeChild();
+            }
+            else {
+                this.lifecycleController.signal.addEventListener('abort', disposeChild, { once: true });
+            }
             child.applyAgent(Object.assign(Object.assign({}, subConfig), { primerHistory: effectivePrimer }));
             // Route interactions back through this driver so widgets render in the
             // parent's (ultimately the root's) history and resolve via the same
@@ -738,6 +827,7 @@ export class ChatDriver extends EventTarget {
                 yield child.sendMessage(task !== null && task !== void 0 ? task : '');
             }
             finally {
+                this.lifecycleController.signal.removeEventListener('abort', disposeChild);
                 child.removeEventListener('history-updated', forwardTrace);
                 child.removeEventListener('provider-changed', forwardProviderChanged);
                 this.dispatchEvent(new CustomEvent('sub-agent-stop', { detail: lifecycleDetail }));
@@ -776,6 +866,7 @@ export class ChatDriver extends EventTarget {
             if (this.busy)
                 return { reason: 'done' };
             this.busy = true;
+            this.beginTurn();
             this.subAgentCompletion = undefined;
             this.subAgentFailure = undefined;
             this.turnStartedAt = Date.now();
@@ -809,6 +900,7 @@ export class ChatDriver extends EventTarget {
                     durationMs: Date.now() - this.turnStartedAt,
                 });
                 this.busy = false;
+                this.endTurn();
                 agenticActivityBus.publish('tool-loop-end', undefined);
             }
         });
@@ -983,11 +1075,17 @@ export class ChatDriver extends EventTarget {
             let firstLlmCall = !!currentInput;
             while (iterations < this.maxToolIterations) {
                 iterations += 1;
+                // A cancel (or dispose) that landed while the previous iteration's tool
+                // batch was running takes effect here — before issuing another LLM call.
+                // An abort during the call itself is handled by the catch below.
+                if (this.turnController.signal.aborted) {
+                    return this.completeAbortedTurn();
+                }
                 const promptCtx = {
                     agentName: (_a = this.activeAgentName) !== null && _a !== void 0 ? _a : '',
                     history: this.history,
                     turnIndex: iterations - 1,
-                    signal: new AbortController().signal,
+                    signal: this.turnController.signal,
                 };
                 // Re-resolve dynamic tool definitions before each LLM call. The static
                 // case is a no-op (factory is undefined and `this.toolDefinitions` was
@@ -1070,6 +1168,9 @@ export class ChatDriver extends EventTarget {
                     // Strip fold-only properties (foldEvent, foldPath) before sending to provider
                     tools: this.toolDefinitions.length ? this.toolDefinitions : undefined,
                     attachments: attachmentsForCall,
+                    // Per-turn signal: aborts on user cancel, and (via beginTurn's chain)
+                    // on driver dispose. Cancels the in-flight request either way.
+                    signal: this.turnController.signal,
                     // Sub-agents must finish by calling a tool (their completion tool), never
                     // by emitting a free-text turn — force tool use so the provider can't
                     // return a bare text answer. Top-level agents stay on the default 'auto'.
@@ -1121,6 +1222,33 @@ export class ChatDriver extends EventTarget {
                         }
                         return { reason: 'done' };
                     }
+                    // A request timeout from the transport (tagged `TimeoutError`) is not a
+                    // bug on our end — surface it distinctly instead of letting it fall
+                    // through to the generic "something went wrong" catch. No auto-retry:
+                    // the timeout ceiling is already minutes long, so a silent retry would
+                    // just make the user wait again.
+                    if (e instanceof DOMException && e.name === 'TimeoutError') {
+                        logger.error('ChatDriver: request timed out', e);
+                        recordTurnError(this.sessionKey, 'exception', {
+                            agent: this.activeAgentName,
+                            provider: this.lastResolvedProviderName,
+                            name: e.name,
+                            message: e.message,
+                        });
+                        this.appendToHistory({
+                            role: 'assistant',
+                            content: 'The request timed out. You can ask me to try again, or break this into a smaller step.',
+                        });
+                        return { reason: 'done' };
+                    }
+                    // The request was aborted: either a user cancel (turnController) or a
+                    // driver dispose (lifecycleController, chained into the turn). A user
+                    // cancel adds a "Stopped." marker; a dispose stops quietly. Handled
+                    // before the transient-retry below so an intentional abort/timeout is
+                    // never retried.
+                    if (e instanceof DOMException && e.name === 'AbortError') {
+                        return this.completeAbortedTurn();
+                    }
                     // A transient provider/transport error should retry the SAME iteration a bounded
                     // number of times rather than tearing down the whole turn (which strands the
                     // agent's unflushed buffer behind an opaque error message).

package/dist/esm/components/chat-driver/chat-driver.test.js

@@ -198,6 +198,196 @@ stale('splits stale vs hallucinated tools on the unknown-tool-limit error', () =
 }));
 stale.run();
 // ---------------------------------------------------------------------------
+// timeout handling — a transport `TimeoutError` surfaces a distinct message
+// ---------------------------------------------------------------------------
+const timeout = createLogicSuite('ChatDriver timeout handling');
+/** A provider whose `chat` rejects with the `TimeoutError` the transports tag
+ * a request timeout with (see gemini/anthropic `post`). */
+const timesOutProvider = () => ({
+    chat: () => __awaiter(void 0, void 0, void 0, function* () {
+        throw new DOMException('Gemini request timed out', 'TimeoutError');
+    }),
+});
+timeout('surfaces a timeout-specific message instead of the generic failure', () => __awaiter(void 0, void 0, void 0, function* () {
+    var _a, _b;
+    clearMetaEventRegistry();
+    const config = agent({
+        name: 'Static',
+        toolDefinitions: [def('noop')],
+        toolHandlers: { noop: () => __awaiter(void 0, void 0, void 0, function* () { return 'ok'; }) },
+    });
+    const sessionKey = 'timeout-test';
+    const driver = makeDriver(config, timesOutProvider(), sessionKey);
+    const result = yield driver.sendMessage('go');
+    assert.is(result.reason, 'done');
+    // The turn ends with the timeout message, NOT the generic "something went wrong".
+    const last = driver.getHistory().at(-1);
+    assert.ok((last === null || last === void 0 ? void 0 : last.role) === 'assistant', 'turn ends with an assistant message');
+    assert.ok(last.content.includes('timed out'), 'message names the timeout');
+    assert.not.ok(last.content.includes('something went wrong'), 'must not fall through to the generic catch');
+    // Recorded distinctly in the debug log: a turn.error tagged TimeoutError,
+    // not swallowed silently.
+    const err = getMetaEvents(sessionKey).find((e) => e.type === 'turn.error');
+    assert.ok(err, 'a turn.error should be recorded');
+    assert.is((_a = err.detail) === null || _a === void 0 ? void 0 : _a.reason, 'exception');
+    assert.is((_b = err.detail) === null || _b === void 0 ? void 0 : _b.name, 'TimeoutError');
+}));
+timeout.run();
+// ---------------------------------------------------------------------------
+// cancellation — dispose() aborts the in-flight provider call (lifecycle signal)
+// ---------------------------------------------------------------------------
+const cancel = createLogicSuite('ChatDriver cancellation');
+cancel('threads a non-aborted signal into the provider call by default', () => __awaiter(void 0, void 0, void 0, function* () {
+    const config = agent({
+        name: 'Static',
+        toolDefinitions: [def('noop')],
+        toolHandlers: { noop: () => __awaiter(void 0, void 0, void 0, function* () { return 'ok'; }) },
+    });
+    const capture = {};
+    const provider = {
+        chat: (_h, _m, options) => __awaiter(void 0, void 0, void 0, function* () {
+            capture.signal = options === null || options === void 0 ? void 0 : options.signal;
+            return { role: 'assistant', content: 'hi' };
+        }),
+    };
+    const driver = makeDriver(config, provider, 'signal-plumb');
+    yield driver.sendMessage('go');
+    assert.ok(capture.signal, 'provider received an options.signal');
+    assert.not.ok(capture.signal.aborted, 'and it is not aborted on a normal turn');
+}));
+cancel('dispose() aborts the in-flight request and stops quietly', () => __awaiter(void 0, void 0, void 0, function* () {
+    var _a;
+    clearMetaEventRegistry();
+    const config = agent({
+        name: 'Static',
+        toolDefinitions: [def('noop')],
+        toolHandlers: { noop: () => __awaiter(void 0, void 0, void 0, function* () { return 'ok'; }) },
+    });
+    // A provider that hangs until its signal aborts, then rejects with the
+    // signal's reason — mirroring how the transport surfaces an aborted fetch.
+    const capture = {};
+    const provider = {
+        chat: (_h, _m, options) => {
+            const signal = options === null || options === void 0 ? void 0 : options.signal;
+            capture.signal = signal;
+            return new Promise((_resolve, reject) => {
+                if (!signal)
+                    return;
+                if (signal.aborted) {
+                    reject(signal.reason);
+                    return;
+                }
+                signal.addEventListener('abort', () => reject(signal.reason), { once: true });
+            });
+        },
+    };
+    const driver = makeDriver(config, provider, 'cancel-test');
+    const pending = driver.sendMessage('go');
+    driver.dispose();
+    const result = yield pending;
+    assert.is(result.reason, 'done');
+    assert.ok((_a = capture.signal) === null || _a === void 0 ? void 0 : _a.aborted, 'the provider signal aborted on dispose');
+    assert.is(capture.signal.reason.name, 'AbortError');
+    // Quiet: no assistant message appended (would otherwise pollute cached history).
+    const assistantMsgs = driver.getHistory().filter((m) => m.role === 'assistant');
+    assert.is(assistantMsgs.length, 0, 'no message appended on a disposal abort');
+    assert.not.ok(driver.getHistory().some((m) => { var _a; return (_a = m.content) === null || _a === void 0 ? void 0 : _a.includes('something went wrong'); }), 'must not surface the generic failure');
+}));
+cancel('cancel() stops the turn with a "Stopped." marker and leaves the driver usable', () => __awaiter(void 0, void 0, void 0, function* () {
+    clearMetaEventRegistry();
+    const config = agent({
+        name: 'Static',
+        toolDefinitions: [def('noop')],
+        toolHandlers: { noop: () => __awaiter(void 0, void 0, void 0, function* () { return 'ok'; }) },
+    });
+    let call = 0;
+    const provider = {
+        chat: (_h, _m, options) => {
+            call += 1;
+            if (call === 1) {
+                // First turn hangs until its signal aborts (the user cancel). Must also
+                // handle the already-aborted case: cancel can land before chat runs
+                // (during the provider-resolution await), so the signal may arrive
+                // aborted — mirror how real fetch rejects immediately in that case.
+                const signal = options.signal;
+                return new Promise((_resolve, reject) => {
+                    if (signal.aborted) {
+                        reject(signal.reason);
+                        return;
+                    }
+                    signal.addEventListener('abort', () => reject(signal.reason), { once: true });
+                });
+            }
+            // Second turn resolves normally — proves the driver wasn't bricked.
+            return Promise.resolve({ role: 'assistant', content: 'second response' });
+        },
+    };
+    const driver = makeDriver(config, provider, 'cancel-stop');
+    const pending = driver.sendMessage('go');
+    driver.cancel();
+    const result = yield pending;
+    assert.is(result.reason, 'done');
+    // Subtle 'Stopped.' marker (system-event, not a generic failure).
+    const last = driver.getHistory().at(-1);
+    assert.is(last === null || last === void 0 ? void 0 : last.role, 'system-event');
+    assert.is(last === null || last === void 0 ? void 0 : last.content, 'Stopped.');
+    // The driver is still usable for the next message.
+    const second = yield driver.sendMessage('again');
+    assert.is(second.reason, 'done');
+    assert.ok(driver.getHistory().some((m) => m.content === 'second response'), 'a fresh turn runs after a cancel');
+}));
+cancel('a tool already running finishes, then the loop stops at the boundary', () => __awaiter(void 0, void 0, void 0, function* () {
+    let toolFinished = false;
+    let secondChatCalled = false;
+    const config = agent({
+        name: 'Static',
+        toolDefinitions: [def('slow')],
+        toolHandlers: {
+            slow: () => __awaiter(void 0, void 0, void 0, function* () {
+                // Cancel mid-tool: the tool must still run to completion.
+                driver.cancel();
+                yield Promise.resolve();
+                toolFinished = true;
+                return 'tool done';
+            }),
+        },
+    });
+    let call = 0;
+    const provider = {
+        chat: () => __awaiter(void 0, void 0, void 0, function* () {
+            call += 1;
+            if (call === 1) {
+                return {
+                    role: 'assistant',
+                    content: '',
+                    toolCalls: [{ id: 't1', name: 'slow', args: {} }],
+                };
+            }
+            secondChatCalled = true;
+            return { role: 'assistant', content: 'should not be reached' };
+        }),
+    };
+    const driver = makeDriver(config, provider, 'cancel-tool');
+    const result = yield driver.sendMessage('go');
+    assert.is(result.reason, 'done');
+    assert.ok(toolFinished, 'the in-flight tool ran to completion (tools are atomic)');
+    assert.not.ok(secondChatCalled, 'no further LLM call is made after cancel');
+    const last = driver.getHistory().at(-1);
+    assert.is(last === null || last === void 0 ? void 0 : last.role, 'system-event');
+    assert.is(last === null || last === void 0 ? void 0 : last.content, 'Stopped.');
+}));
+cancel('cancel() is a no-op when no turn is running', () => {
+    const config = agent({
+        name: 'Static',
+        toolDefinitions: [def('noop')],
+        toolHandlers: { noop: () => __awaiter(void 0, void 0, void 0, function* () { return 'ok'; }) },
+    });
+    const driver = makeDriver(config, scriptedProvider([]), 'cancel-idle');
+    driver.cancel(); // must not throw or append anything while idle
+    assert.is(driver.getHistory().length, 0);
+});
+cancel.run();
+// ---------------------------------------------------------------------------
 // sub-agents — forced tool use + typed completion/failure union (GENC-1312)
 //
 // A child sub-agent driver shares the parent's provider registry, so one

package/dist/esm/components/orchestrating-driver/orchestrating-driver.js

@@ -62,6 +62,12 @@ export class OrchestratingDriver extends EventTarget {
          * so long-running `onActivate` work can bail if the session disconnects.
          */
         this.lifecycleAbortController = new AbortController();
+        /**
+         * Set by `cancel()` for the duration of a `sendMessage` run. Breaks the
+         * handoff loop so we don't classify or start another agent turn after the
+         * user stops. Reset at the start of each `sendMessage`.
+         */
+        this.cancelled = false;
         /**
          * Sticky user pick from the picker (or the host's `setAgent` API). Only
          * changes on explicit user action. Survives flow completion: when a stateful
@@ -177,6 +183,7 @@ export class OrchestratingDriver extends EventTarget {
     }
     sendMessage(input, attachments) {
         return __awaiter(this, void 0, void 0, function* () {
+            this.cancelled = false;
             const history = this.chatDriver.getHistory();
             // Emit the user message immediately so the UI reflects it during the classify
             // round-trip — without this the chat appears frozen until classify returns.
@@ -192,6 +199,11 @@ export class OrchestratingDriver extends EventTarget {
             let handoffSummary = '';
             let remainingTask = '';
             while (true) {
+                // Cancelled before a (next) agent turn started — e.g. during classify.
+                // The chat driver appends its own "Stopped." marker when a turn it was
+                // running is cancelled, so we just stop here without a duplicate.
+                if (this.cancelled)
+                    break;
                 // oxlint-disable-next-line no-await-in-loop
                 yield this.applyAgent(currentAgent);
                 let result;
@@ -370,6 +382,15 @@ export class OrchestratingDriver extends EventTarget {
             this.dispatchEvent(new CustomEvent('agent-changed', { detail: undefined }));
         });
     }
+    /**
+     * Stop the current turn (user "stop" button). Cancels the inner chat driver's
+     * in-flight request and breaks the handoff loop so no further agent turn or
+     * classify runs. The driver stays usable for the next message.
+     */
+    cancel() {
+        this.cancelled = true;
+        this.chatDriver.cancel();
+    }
     /**
      * Fire `onDeactivate` on the current active agent and abort any pending
      * lifecycle work. Called by the host on session teardown so machines can
@@ -391,6 +412,8 @@ export class OrchestratingDriver extends EventTarget {
                 }
             }
             this.lifecycleAbortController.abort();
+            // Tear down the inner driver too, so any in-flight provider request aborts.
+            this.chatDriver.dispose();
             this.activeAgent = undefined;
         });
     }

package/dist/esm/main/main.js

@@ -200,10 +200,11 @@ let FoundationAiAssistant = FoundationAiAssistant_1 = class FoundationAiAssistan
             this.logMeta('state.changed', { from: prev, to: value });
         }
         this.syncShowHalo();
-        // When the agent finishes (loading → !loading) the input row reappears (or
-        // becomes enabled) — refocus it so the user can type immediately, but only
-        // if they haven't moved on to something else on the page.
-        if (prev === 'loading' && value !== 'loading') {
+        // When the turn finishes (a busy state → a settled one) the input row
+        // reappears (or becomes enabled) — refocus it so the user can type
+        // immediately, but only if they haven't moved on to something else.
+        // `cancelling` is busy too, so loading → cancelling must NOT settle yet.
+        if (this.isBusyState(prev) && !this.isBusyState(value)) {
             this.maybeAutoFocusChatInput();
             // Apply any agents swap deferred by the busy guard in `agentsChanged`.
             // Host-side `agents` getters typically cache a stable reference between
@@ -212,6 +213,20 @@ let FoundationAiAssistant = FoundationAiAssistant_1 = class FoundationAiAssistan
             this.applyDeferredAgentsSwap();
         }
     }
+    /** Whether a state value counts as "busy" — a turn is active. */
+    isBusyState(s) {
+        return s === 'loading' || s === 'cancelling';
+    }
+    /**
+     * True while a turn is active — `loading` or `cancelling` (a stop was
+     * requested but the turn is still winding down). The single "is a turn
+     * running" predicate; UI gates use this so `cancelling` behaves like
+     * `loading` everywhere. `@volatile` so the template re-evaluates it when the
+     * store-backed `state` changes.
+     */
+    get busy() {
+        return this.isBusyState(this.state);
+    }
     /**
      * Re-runs `agentsChanged` if the live `agents` array no longer matches the
      * fingerprint of the currently installed driver. Used to apply swaps that
@@ -463,7 +478,7 @@ let FoundationAiAssistant = FoundationAiAssistant_1 = class FoundationAiAssistan
         (_a = this._sessionRef) === null || _a === void 0 ? void 0 : _a.actions.aiAssistant.setInputValue(value);
     }
     syncShowHalo() {
-        if (this.state !== 'loading') {
+        if (!this.busy) {
             this.showHalo = 'no';
             return;
         }
@@ -477,7 +492,7 @@ let FoundationAiAssistant = FoundationAiAssistant_1 = class FoundationAiAssistan
     }
     /** True when there is a pending (unresolved) interaction — disables the popout button. */
     get hasActivePendingInteraction() {
-        if (this.state !== 'loading')
+        if (!this.busy)
             return false;
         const last = this.messages[this.messages.length - 1];
         return !!(last === null || last === void 0 ? void 0 : last.interaction) && !last.interaction.resolved;
@@ -909,7 +924,7 @@ let FoundationAiAssistant = FoundationAiAssistant_1 = class FoundationAiAssistan
         document.addEventListener('focusin', this._handleGlobalInteraction, true);
         // Initial focus on mount when idle (skips during a mid-lifecycle reattach
         // where state is loading and the input may be hidden or disabled).
-        if (this.state !== 'loading')
+        if (!this.busy)
             this.maybeAutoFocusChatInput();
         logger.debug('FoundationAiAssistant connected');
         this.logMeta('assistant.connected', {
@@ -1006,7 +1021,7 @@ let FoundationAiAssistant = FoundationAiAssistant_1 = class FoundationAiAssistan
         // individual step gets a fresh window before the spinner appears.
         // If the last message is a blocking interaction, stop the timer — the AI is
         // waiting for the user, not computing.
-        if (this.state === 'loading') {
+        if (this.busy) {
             const last = this.messages[this.messages.length - 1];
             if (last === null || last === void 0 ? void 0 : last.interaction) {
                 this.stopLoadingTimer();
@@ -1486,6 +1501,19 @@ let FoundationAiAssistant = FoundationAiAssistant_1 = class FoundationAiAssistan
     handleSendClick() {
         this.send();
     }
+    /**
+     * User clicked Stop. Cancels the current turn via the driver and flips the
+     * button to "Stopping…" until the turn winds down (a tool mid-execution
+     * finishes first). Guarded so a second click is a no-op.
+     */
+    handleStopClick() {
+        var _a, _b;
+        // Only valid mid-turn; once `cancelling`, a second click is a no-op.
+        if (this.state !== 'loading')
+            return;
+        this.state = 'cancelling';
+        (_b = (_a = this.driver) === null || _a === void 0 ? void 0 : _a.cancel) === null || _b === void 0 ? void 0 : _b.call(_a);
+    }
     handleSuggestionClick(suggestion) {
         this.inputValue = suggestion;
         this.send();
@@ -1514,7 +1542,7 @@ let FoundationAiAssistant = FoundationAiAssistant_1 = class FoundationAiAssistan
     submitMessage(input) {
         return __awaiter(this, void 0, void 0, function* () {
             var _a, _b, _c;
-            if (this.state === 'loading') {
+            if (this.busy) {
                 return { ok: false, errors: ['Assistant is busy'] };
             }
             let nextAttachments = [];
@@ -1527,7 +1555,7 @@ let FoundationAiAssistant = FoundationAiAssistant_1 = class FoundationAiAssistan
                 // own first await — so no further race window exists.
                 // (Cast widens through TS's narrowing of `this.state` from the earlier
                 // early-return; the getter can return a different value across an await.)
-                if (this.state === 'loading') {
+                if (this.busy) {
                     return { ok: false, errors: ['Assistant is busy'] };
                 }
                 if (errors.length) {
@@ -1614,7 +1642,7 @@ let FoundationAiAssistant = FoundationAiAssistant_1 = class FoundationAiAssistan
         return __awaiter(this, void 0, void 0, function* () {
             var _a;
             const input = this.inputValue.trim();
-            if ((!input && !this.attachments.length) || this.state === 'loading')
+            if ((!input && !this.attachments.length) || this.busy)
                 return;
             // Capture the session ref before any await. If a lifecycle event occurs during
             // execution, disconnectedCallback clears this._sessionRef — but the captured
@@ -1645,7 +1673,14 @@ let FoundationAiAssistant = FoundationAiAssistant_1 = class FoundationAiAssistan
                 // Write directly via captured ref — this._sessionRef may be null if the element
                 // disconnected mid-execution. The state setter also calls syncShowHalo(); replicate
                 // that here for the case where this element is still connected.
+                const prevState = capturedSessionRef === null || capturedSessionRef === void 0 ? void 0 : capturedSessionRef.store.aiAssistant.state;
                 capturedSessionRef === null || capturedSessionRef === void 0 ? void 0 : capturedSessionRef.actions.aiAssistant.setState('idle');
+                // The setter's `state.changed` log is bypassed on this direct write, so
+                // emit it here — otherwise the debug timeline shows the turn entering
+                // loading/cancelling but never returning to idle.
+                if (prevState && prevState !== 'idle') {
+                    this.logMeta('state.changed', { from: prevState, to: 'idle' });
+                }
                 this.syncShowHalo();
                 this.fetchSuggestions();
                 // setState was dispatched directly via the captured ref (not via the
@@ -1715,6 +1750,9 @@ __decorate([
 __decorate([
     attr({ attribute: 'debug-redux', mode: 'boolean' })
 ], FoundationAiAssistant.prototype, "debugRedux", void 0);
+__decorate([
+    volatile
+], FoundationAiAssistant.prototype, "busy", null);
 __decorate([
     volatile
 ], FoundationAiAssistant.prototype, "effectiveChatInputDuringExecution", null);