@theoremjs/web 0.3.4-next.409.g25ad907 → 0.3.4-next.413.gb7a2b75

package/README.md

@@ -185,17 +185,17 @@ await chat.submit();
 | Method | What it does |
 | --- | --- |
 | `submit()` | At `idle`, sends the draft. Otherwise, queues it. |
-| `enqueue('steer')` | Sends the draft to the running turn with `transport.steer`. The steer leaves `pendingMessages` when the turn's `stage` event names it in `injected`. A steer the turn never takes waits at the front of the queue. |
+| `enqueue('steer')` | Sends the draft to the running turn with `transport.steer`. The steer leaves `pendingMessages` when the turn's `stage` event names it in `injected`, and joins the transcript there, between the reply before it and the reply after. A steer the turn never takes waits at the front of the queue. |
 | `enqueue('queue')` | Keeps the draft to send after the reply. When the reply ends without a failure and no gate waits, the first queued message is sent. |
 | `enqueue('stash')` | Keeps the draft without sending it. `queuePending(id)` moves it to the queue. |
-| `sendNow(message?)` | Sends a pending message, or the draft, at once. A streaming reply is stopped first. A reply that waits on gates is left. |
+| `sendNow(message?)` | Sends a pending message, or the draft, at once. A streaming reply is stopped first, as `stop()` stops it. A reply that waits on gates is left. |
 | `restorePending(id)` | Puts a pending message back in the composer. The draft that was there is stashed first, so the user loses nothing. |
-| `stop()` | Stops the streaming reply. |
+| `stop()` | Stops the streaming reply with `transport.stop`. What the reply said before the stop stays in the transcript and the history, closed as cancelled. A queued message stays queued. When the host refuses the stop, the controller drops the stream instead, and a host that keeps the conversation keeps the stopped reply where the page can't read it. |
 | `decide(action)`, `authenticate(secret?)` | Answer the gate that the reply waits on. |
 | `branch(index)` | Cuts the conversation after transcript block `index`. |
 | `sendText(text, files?)` | Sends a message from your code. It resolves with the blocks the turn added, or `null` when the chat cannot take a message now. |
 
-The controller uses these methods of the transport: `turn`, `invoke` (to answer a gate), `steer`, `conversation`, and `rewind`. `conversation` and `rewind` are called only for a profile whose host keeps the conversation. `pageResult` is called when the reply hands a tool to the page.
+The controller uses these methods of the transport: `turn`, `invoke` (to answer a gate), `steer`, `stop`, `conversation`, and `rewind`. `conversation` and `rewind` are called only for a profile whose host keeps the conversation. `pageResult` is called when the reply hands a tool to the page.
 
 The controller writes no English text. The helpers below give the composer's controls as values, and you choose the words:
 
@@ -237,7 +237,7 @@ const transport = withPageToolDispatch(
 | `host` | App data for the tool handlers (`ctx.host`), such as the signed-in user. |
 | `pageToolBroker` | Delivers results to active page dispatches. Default: bounded process memory. |
 | `conversationStore` | Where the conversation is kept. Required, except for a stateless profile, which must not have one. See [Keep the conversation](#keep-the-conversation). |
-| `sessionStore`, `steerInbox` | Where open gates and queued steers are kept. Default: process memory. |
+| `sessionStore`, `steerInbox` | Where open gates are kept, and where steers and stops reach a running turn. Default: process memory, which reaches only turns this process runs. On more than one instance, give a shared `SteerInbox`. |
 | `credentialStore` | Where tool credentials are kept, by session. Default: process memory. |
 | `authorizationUrl` | Returns the sign-in URL for an OAuth gate. Without it, an OAuth gate has no URL. |
 | `gateTtlMs` | How long a gate waits for an answer. Default: 30 minutes. A later answer fails with `session.gate_expired`. |

package/client/chat.js

@@ -7,7 +7,7 @@ import { clientFailure, turnFailure } from "./failure.js";
 import { followGenerationDefaults } from "./generation-selection.js";
 import { warnPageToolMismatch } from "./live/live-page-tool.js";
 import { withPageToolDispatch } from "./page-dispatch.js";
-import { sessionAfter, stampWorked } from "./run-commit.js";
+import { sessionAfter, stampWorked, stoppedReply } from "./run-commit.js";
 import { keepsConversation, resumeInterfaceTool, streamInterfaceDraftTurn, streamInterfaceTurn, } from "./run-session.js";
 import { isUnknownConversation, } from "./transport.js";
 import { foldAssistantTurn, issuedOperationId } from "./turn-client.js";
@@ -90,6 +90,8 @@ class Chat {
     #busy = false;
     #abort = null;
     #turnId = null;
+    /** The visitor stopped the run in flight, so the queue waits. */
+    #stopped = false;
     /** The run in flight; it settles, never rejects. */
     #run = null;
     // why: A stateless reply's work across its runs: a gate splits a reply into runs, and the wait between doesn't count.
@@ -170,8 +172,27 @@ class Chat {
         await this.#sendFields({ text: draftText, files: [...pendingFiles], voice: [...pendingVoice] });
     };
     stop = () => {
-        this.#abort?.abort();
+        void this.#stop();
     };
+    /** Asks the host to stop the turn, so the reply it leaves comes back; a host that can't drops the stream. */
+    async #stop() {
+        const abort = this.#abort;
+        const turnId = this.#turnId;
+        if (!abort)
+            return;
+        this.#stopped = true;
+        if (!turnId) {
+            abort.abort();
+            return;
+        }
+        try {
+            await this.#options.transport.stop({ turnId });
+        }
+        catch {
+            // why: The host isn't running the turn here (it ended, or another instance runs it); the stream is dropped instead.
+            abort.abort();
+        }
+    }
     enqueue = async (kind) => {
         const { draftText, pendingFiles, pendingVoice } = this.#state;
         if (!composerHasPayload(draftText, pendingFiles, pendingVoice))
@@ -207,7 +228,7 @@ class Chat {
         if (!draft)
             return;
         if (this.#busy) {
-            this.#abort?.abort();
+            await this.#stop();
             await this.#run;
         }
         this.#set({ pendingMessages: convertSteersToFrontQueued(this.#state.pendingMessages) });
@@ -652,6 +673,7 @@ class Chat {
         this.#busy = true;
         this.#abort = abort;
         this.#turnId = turnId ?? null;
+        this.#stopped = false;
         this.#drainArmed = false;
         // why: A message streams once it posts, so the previous reply never shows as streaming before it.
         this.#set({ failure: null, ...(message ? {} : { streaming: true }) });
@@ -691,7 +713,7 @@ class Chat {
                 else {
                     waits = this.#settleLocal(iface, outcome, { workedMs: this.#replyWorkedMs, endedAt });
                 }
-                this.#runEnded(!outcome.failure && !waits);
+                this.#runEnded(!outcome.failure && !waits && !this.#stopped);
             }
             catch (err) {
                 // why: The run left no view to draw; the composer says so, and the chat stays as it stood.
@@ -775,7 +797,7 @@ class Chat {
         }
         this.#setDelivery(null);
         const closing = failure.aborted
-            ? [{ id: crypto.randomUUID(), kind: 'turn-done', stop: { kind: 'cancelled' } }]
+            ? stampWorked(stoppedReply(reply), worked)
             : withTurnError(reply, failure.error);
         this.#set({
             session,

package/client/index.d.ts

@@ -33,5 +33,5 @@ export { hasLead, layoutResult, type ResultChart, type ResultFigure, type Result
 export type { AnsweringGate, ToolDecisionAction, ToolGateResolution, } from './tool-resume.ts';
 export { continueGatedToolInvocation, type PersonGateResolution } from './tool-resume.ts';
 export { createTraceFeed, type TraceFeed } from './trace-feed.ts';
-export { CHAT_LINES, type ChatLine, type ChatLineSink, type ClientTurnEvent, type ConversationLine, type ConversationView, createHttpTransport, fetchConversation, fetchRewound, fetchStarted, type HostErrorBody, type HttpOptions, type HttpTransportOptions, hostError, isTheoremStreamError, type MalformedEvent, postJson, postNdjson, readNdjsonStream, type TheoremConversationRequest, type TheoremInvokeRequest, type TheoremReplay, type TheoremRewindRequest, type TheoremRewound, type TheoremStartRequest, type TheoremSteerRequest, TheoremStreamError, type TheoremTransport, type TheoremTurnInput, type TheoremTurnRequest, type TurnEventSink, type UnsupportedEvent, type WireLines, } from './transport.ts';
+export { CHAT_LINES, type ChatLine, type ChatLineSink, type ClientTurnEvent, type ConversationLine, type ConversationView, createHttpTransport, fetchConversation, fetchRewound, fetchStarted, type HostErrorBody, type HttpOptions, type HttpTransportOptions, hostError, isTheoremStreamError, type MalformedEvent, postJson, postNdjson, readNdjsonStream, type TheoremConversationRequest, type TheoremInvokeRequest, type TheoremReplay, type TheoremRewindRequest, type TheoremRewound, type TheoremStartRequest, type TheoremSteerRequest, type TheoremStopRequest, TheoremStreamError, type TheoremTransport, type TheoremTurnInput, type TheoremTurnRequest, type TurnEventSink, type UnsupportedEvent, type WireLines, } from './transport.ts';
 export { buildInvokeRequest, buildTurnRequest, foldAssistantTurn, issuedOperationId, type RunScope, type WalkAway, } from './turn-client.ts';

package/client/page-dispatch.js

@@ -56,6 +56,7 @@ export function withPageToolDispatch(transport, tools) {
         invoke: (request, onLine, signal) => transport.invoke(request, chatSink(onLine, signal), signal),
         turn: (request, onLine, signal) => transport.turn(request, chatSink(onLine, signal), signal),
         steer: transport.steer.bind(transport),
+        stop: transport.stop.bind(transport),
         conversation: transport.conversation.bind(transport),
         rewind: transport.rewind.bind(transport),
     };

package/client/run-commit.d.ts

@@ -32,3 +32,8 @@ export declare function stampWorked(blocks: TranscriptBlock[], worked: {
     workedMs: number;
     endedAt: number;
 }): TranscriptBlock[];
+/**
+ * A reply the person stopped, as far as it went: what they saw stays, and it closes as cancelled
+ * unless the stream already closed it.
+ */
+export declare function stoppedReply(blocks: TranscriptBlock[]): TranscriptBlock[];

package/client/run-commit.js

@@ -47,3 +47,12 @@ export function stampWorked(blocks, worked) {
         return blocks;
     return blocks.map((block, index) => (index === last ? { ...block, ...worked } : block));
 }
+/**
+ * A reply the person stopped, as far as it went: what they saw stays, and it closes as cancelled
+ * unless the stream already closed it.
+ */
+export function stoppedReply(blocks) {
+    if (blocks.some((block) => block.kind === 'turn-done'))
+        return blocks;
+    return [...blocks, { id: crypto.randomUUID(), kind: 'turn-done', stop: { kind: 'cancelled' } }];
+}

package/client/transport.d.ts

@@ -120,6 +120,12 @@ export type TheoremSteerRequest = {
 };
 /** A `/steer` body as `createTheoremHandler` reads it. */
 export declare const theoremSteerRequestSchema: z.ZodType<TheoremSteerRequest>;
+/** Stop an in-flight turn where it stands; its stream ends with what the reply left. */
+export type TheoremStopRequest = {
+    turnId: string;
+};
+/** A `/stop` body as `createTheoremHandler` reads it. */
+export declare const theoremStopRequestSchema: z.ZodType<TheoremStopRequest>;
 /**
  * The ref the store issued for the conversation a run wrote: the client sends
  * it with its next request. It comes before the run's error, which ends the stream.
@@ -181,6 +187,8 @@ export interface TheoremTransport {
     turn(request: TheoremTurnRequest, onLine: ChatLineSink, signal?: AbortSignal): Promise<void>;
     invoke(request: TheoremInvokeRequest, onLine: ChatLineSink, signal?: AbortSignal): Promise<void>;
     steer(request: TheoremSteerRequest): Promise<void>;
+    /** Stops the turn; refused (`session.turn_ended`) when this host is not running it. */
+    stop(request: TheoremStopRequest): Promise<void>;
     /** The conversation under `ref`, as the host shows it. */
     conversation(request: TheoremConversationRequest, signal?: AbortSignal): Promise<ConversationView>;
     /** The conversation cut after a transcript block, under the ref the host issued for it. */

package/client/transport.js

@@ -83,6 +83,10 @@ const theoremSteerRequest = z.object({
 true;
 /** A `/steer` body as `createTheoremHandler` reads it. */
 export const theoremSteerRequestSchema = theoremSteerRequest;
+const theoremStopRequest = z.object({ turnId: clientId });
+true;
+/** A `/stop` body as `createTheoremHandler` reads it. */
+export const theoremStopRequestSchema = theoremStopRequest;
 const conversationLine = z.object({
     type: z.literal('conversation'),
     ref: z.string().min(1),
@@ -339,5 +343,6 @@ export function createHttpTransport(options = {}) {
         rewind: (body, signal) => fetchRewound(`${base}/rewind`, body, { ...options, signal }),
         pageResult: (body, signal) => postJson(`${base}/page-result`, body, { ...options, signal }),
         steer: (body) => postJson(`${base}/steer`, body, options),
+        stop: (body) => postJson(`${base}/stop`, body, options),
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@theoremjs/web",
-  "version": "0.3.4-next.409.g25ad907",
+  "version": "0.3.4-next.413.gb7a2b75",
   "description": "Theorem on the web platform, with no UI framework: Web-standard server handlers that serve a profile, and the browser client that talks to them.",
   "license": "MIT",
   "type": "module",
@@ -25,6 +25,6 @@
   },
   "peerDependencies": {
     "zod": "^4.6.5",
-    "@theoremjs/agents": "^0.3.4-next.409.g25ad907"
+    "@theoremjs/agents": "^0.3.4-next.413.gb7a2b75"
   }
 }

package/server/conversation.js

@@ -19,7 +19,7 @@ import { sanitizeTurnRequestWithEvents, withPublicLabels } from '@theoremjs/agen
 import { forClient } from '@theoremjs/agents/host';
 import { appendAssistantEventsToHistory, appendUserDraftToHistory, applyTurnEventsToSession, emptyInterfaceTurnSession, foldTurnEvents, gatedToolsFromEvents, historyFromTranscriptBlocks, prepareUserTurn, settlesToolCall, streamThoughtsEnabled, } from '@theoremjs/agents/interface';
 import { base64ToBytes } from '@theoremjs/agents/kernel';
-import { stampWorked } from "../client/run-commit.js";
+import { stampWorked, stoppedReply } from "../client/run-commit.js";
 import { emptyConversation, unknownConversation, } from "./conversation-store.js";
 import { kernelTurnInput } from "./turn-input.js";
 /** The paused call a reference names, when its call id and its operation both match. */
@@ -166,15 +166,15 @@ function metered(conversation, events) {
         ...(applied.historyTokens === undefined ? {} : { historyTokens: applied.historyTokens }),
     };
 }
-/** The reply is over: its blocks join the transcript and its events the history. */
-function committed(host, conversation, reply) {
+/** The reply is over: its blocks, as `closing` ends them, join the transcript and its events the history. */
+function committed(host, conversation, reply, closing = (blocks) => blocks) {
     const { paused: _paused, providerState: _state, ...rest } = conversation;
     return {
         ...rest,
         ...metered(conversation, reply.events),
         transcript: [
             ...conversation.transcript,
-            ...stampWorked(foldedFor(host, reply.events), {
+            ...stampWorked(closing(foldedFor(host, reply.events)), {
                 workedMs: reply.workedMs,
                 endedAt: Date.now(),
             }),
@@ -210,19 +210,11 @@ function failed(host, conversation, reply, failure) {
     };
 }
 /**
- * The person stopped the reply: it leaves the transcript, and the history
- * keeps what came before this run, the calls it settled included.
+ * The person stopped the reply: what they saw of it stays, in the transcript and the history
+ * alike, closed as cancelled. A call still running when it stopped enters neither.
  */
-function stopped(conversation, reply) {
-    const { paused: _paused, ...rest } = conversation;
-    return {
-        ...rest,
-        transcript: [
-            ...conversation.transcript,
-            { id: crypto.randomUUID(), kind: 'turn-done', stop: { kind: 'cancelled' } },
-        ],
-        history: appendAssistantEventsToHistory(reply.base, reply.events.slice(reply.baseEvents, Math.max(reply.baseEvents, reply.seed))),
-    };
+function stopped(host, conversation, reply) {
+    return committed(host, conversation, reply, stoppedReply);
 }
 /**
  * Runs the model for `reply` and writes what it leaves. A compaction moves the
@@ -258,14 +250,17 @@ async function* runReply(host, opened, reply, runner, input, withMessage) {
     }
     catch (err) {
         current = await save(host, current, runner.signal.aborted
-            ? stopped(conversation, worked())
+            ? stopped(host, conversation, worked())
             : failed(host, conversation, worked(), toErrorEvent(err)));
         yield* refLine(current);
-        throw err;
+        // why: A stopped reply is no failure; the browser draws what it left from the ref.
+        if (!runner.signal.aborted)
+            throw err;
+        return;
     }
     const settled = worked();
     if (runner.signal.aborted) {
-        current = await save(host, current, stopped(conversation, settled));
+        current = await save(host, current, stopped(host, conversation, settled));
     }
     else if (errorEvent) {
         current = await save(host, current, failed(host, conversation, settled, errorEvent));
@@ -396,7 +391,6 @@ function pausedReply(paused) {
         base: paused.base,
         events: [...paused.events],
         baseEvents: paused.baseEvents,
-        seed: paused.events.length,
         workedMs: paused.workedMs,
     };
 }
@@ -443,7 +437,6 @@ export async function* messageReply(args) {
         base: withMessage(conversation.history),
         events: [],
         baseEvents: 0,
-        seed: 0,
         workedMs: 0,
     };
     yield* runReply(host, opened, reply, runner, {
@@ -478,7 +471,6 @@ export async function* answerReply(args) {
         yield event;
     }
     reply.workedMs += Date.now() - startedAt;
-    reply.seed = reply.events.length;
     if (error || gatedToolsFromEvents(reply.events).length) {
         // why: An answer that failed before its call settled leaves the reply as it was, to answer again.
         const settledCall = reply.events.some((event) => settlesToolCall(event, args.call.callId));

package/server/handler.js

@@ -38,7 +38,7 @@ import { caughtStatus, clientError, forClient, HTTP_METHOD, } from '@theoremjs/a
 import { clientProfileInterface, gatedToolsFromEvents, interfaceFromProfile, promotedToolIdsFromEvents, toolSnapshotFromEvents, } from '@theoremjs/agents/interface';
 import { answerGatedCall, resolveGateTtlMs, } from '@theoremjs/agents/kernel';
 import { hostInterface, theoremHostCallRequestSchema, } from "../client/host-transport.js";
-import { theoremConversationRequestSchema, theoremInvokeRequestSchema, theoremRewindRequestSchema, theoremSteerRequestSchema, theoremTurnRequestSchema, } from "../client/transport.js";
+import { theoremConversationRequestSchema, theoremInvokeRequestSchema, theoremRewindRequestSchema, theoremSteerRequestSchema, theoremStopRequestSchema, theoremTurnRequestSchema, } from "../client/transport.js";
 import { answerReply, conversationView, messageReply, openConversation, postedMessage, readerConversationHost, requiredOperationId, rewindConversation, statelessRefusal, waitingCalls, } from "./conversation.js";
 import { unknownConversation } from "./conversation-store.js";
 import { createMemoryCredentialStore, } from "./credential-store.js";
@@ -50,7 +50,7 @@ import { boundedRequestJson, requestByteLimit } from "./request-body.js";
 import { checkRequest } from "./request-check.js";
 import { resolveSessionLimits } from "./session-limits.js";
 import { createMemorySessionStore, DEFAULT_OPERATION_RETENTION_MS, } from "./session-store.js";
-import { createMemorySteerInbox, steerStage, steerUnitOf } from "./steer-inbox.js";
+import { createMemorySteerInbox, steerStage, steerUnitOf, stopOnRequest, } from "./steer-inbox.js";
 import { sameAcceptedAnswer, sessionToolCoordinator } from "./tool-operations.js";
 const NDJSON_HEADERS = {
     'content-type': 'application/x-ndjson; charset=utf-8',
@@ -90,6 +90,7 @@ function routeOf(request) {
     return last === 'turn' ||
         last === 'invoke' ||
         last === 'steer' ||
+        last === 'stop' ||
         last === 'conversation' ||
         last === 'rewind' ||
         last === 'call' ||
@@ -386,13 +387,14 @@ async function* once(event, labels) {
     yield withPublicLabels(event, labels);
 }
 /** One model run of a chat's reply, its gates recorded in the session as they pause. */
-async function* chatTurn(ctx, request, session, turn, turnId) {
+async function* chatTurn(ctx, request, session, turn, key, stop) {
     const state = await ctx.sessions.read(session.id);
     const provider = await providerFor(ctx, request, turn.model);
     const host = await ctx.options.host?.(request);
-    const key = turnId ? inboxKey(session.id, turnId) : undefined;
-    if (key)
+    if (key) {
         await ctx.inbox.open(key);
+        stopOnRequest(ctx.inbox, key, stop);
+    }
     try {
         const events = runTurn({
             profile: ctx.profile.id,
@@ -402,7 +404,7 @@ async function* chatTurn(ctx, request, session, turn, turnId) {
             ...(turn.providerState ? { providerState: turn.providerState } : {}),
             sessionPermissions: state.permissions,
             credentials: sessionCredentials(ctx, session.id),
-            signal: request.signal,
+            signal: AbortSignal.any([request.signal, stop.signal]),
             host,
             ...(turn.model ? { model: turn.model } : {}),
             ...(turn.effort ? { effort: turn.effort } : {}),
@@ -419,24 +421,27 @@ async function* chatTurn(ctx, request, session, turn, turnId) {
             await ctx.inbox.close(key);
     }
 }
-/** How this request runs the model for a reply: its generation, and the request's abort. */
+/** How this request runs the model for a reply: its generation, and its abort (the request's, or a stop). */
 function chatRunner(ctx, request, session, generation) {
+    const key = generation.turnId ? inboxKey(session.id, generation.turnId) : undefined;
+    const stop = new AbortController();
+    const signal = AbortSignal.any([request.signal, stop.signal]);
     return {
-        run: (turn) => chatTurn(ctx, request, session, turn, generation.turnId),
+        run: (turn) => chatTurn(ctx, request, session, turn, key, stop),
         async compact(history, tokens, model) {
             const provider = await providerFor(ctx, request, model);
             const compacted = await compactHistory({
                 profile: ctx.profile.id,
                 history,
                 tokens,
-                signal: request.signal,
+                signal,
                 ...(model ? { model } : {}),
             }, provider);
             return compacted?.history;
         },
         ...(generation.model ? { model: generation.model } : {}),
         ...(generation.effort ? { effort: generation.effort } : {}),
-        signal: request.signal,
+        signal,
     };
 }
 /** The chat's conversation as this session's runs read and write it; undefined when the profile keeps none. */
@@ -541,6 +546,17 @@ async function steer(ctx, request, session) {
     }
     return jsonResponse(200, { ok: true });
 }
+/** Stops a running turn where it stands; its stream goes on to save and send what the reply left. */
+async function stop(ctx, request, session) {
+    const body = await readBody(request, theoremStopRequestSchema, ctx.options.maxRequestBytes);
+    if (!(await ctx.inbox.stop(inboxKey(session.id, body.turnId)))) {
+        // labels-exempt: internal diagnostic; the user reads the error kind's (or copy key's) wording
+        throw new TheoremError('request', `turn ${body.turnId} is not running`, {
+            copy: { key: 'session.turn_ended' },
+        });
+    }
+    return jsonResponse(200, { ok: true });
+}
 /** One call of one of a host's tools, run as the page asked it; a gate it pauses on waits in the session. */
 async function* callEvents(ctx, request, session, body) {
     const state = await ctx.sessions.read(session.id);
@@ -688,6 +704,8 @@ async function route(ctx, request, session) {
         return conversation(ctx, request, session);
     if (target === 'rewind')
         return rewind(ctx, request, session);
+    if (target === 'stop')
+        return stop(ctx, request, session);
     return steer(ctx, request, session);
 }
 export function createTheoremHandler(options) {

package/server/mod.d.ts

@@ -7,7 +7,7 @@
  */
 export { theoremHostCallRequestSchema } from '../client/host-transport.ts';
 export type { LiveClientMessage, LiveOpenMessage } from '../client/live-messages.ts';
-export { theoremConversationRequestSchema, theoremInvokeRequestSchema, theoremReplaySchema, theoremRewindRequestSchema, theoremStartRequestSchema, theoremSteerRequestSchema, theoremTurnRequestSchema, } from '../client/transport.ts';
+export { theoremConversationRequestSchema, theoremInvokeRequestSchema, theoremReplaySchema, theoremRewindRequestSchema, theoremStartRequestSchema, theoremSteerRequestSchema, theoremStopRequestSchema, theoremTurnRequestSchema, } from '../client/transport.ts';
 export { answerReply, type ConversationHost, type ConversationUse, conversationView, type IssuedWalkAway, messageReply, type OpenedConversation, openConversation, type PostedMessage, postedMessage, type ReplyLine, type ReplyRunner, type ReplyTurn, readerConversationHost, rewindConversation, startConversation, statelessRefusal, type WalkedAwayCall, waitingCalls, } from './conversation.ts';
 export { type ConversationSnapshot, type ConversationWriteResult, createMemoryConversationStore, createSealedConversationStore, emptyConversation, type PausedReply, type SealedConversationStoreOptions, type StoredConversation, storedConversationSchema, type TheoremConversationStore, unknownConversation, } from './conversation-store.ts';
 export { createMemoryCredentialStore, type TheoremCredentialStore, type TheoremCredentials, } from './credential-store.ts';
@@ -22,6 +22,6 @@ export { createTheoremSessionBoundary, type PreparedLiveOpen, type SessionBounda
 export type { TheoremSessionLimits } from './session-limits.ts';
 export { resolveSessionLimits } from './session-limits.ts';
 export { createMemorySessionStore, DEFAULT_OPERATION_RETENTION_MS, type MemorySessionStoreOptions, type PendingToolGate, type SessionSnapshot, type SessionToolOperation, type SessionWriteResult, type TheoremSessionState, type TheoremSessionStore, theoremSessionStateSchema, } from './session-store.ts';
-export { createMemorySteerInbox, type SteerInbox, type SteerUnit, steerStage, steerUnitOf, } from './steer-inbox.ts';
+export { createMemorySteerInbox, type SteerInbox, type SteerUnit, steerStage, steerUnitOf, stopOnRequest, } from './steer-inbox.ts';
 export { sessionToolCoordinator } from './tool-operations.ts';
 export { kernelTurnInput, liveSessionOpen } from './turn-input.ts';

package/server/mod.js

@@ -6,7 +6,7 @@
  * @module
  */
 export { theoremHostCallRequestSchema } from "../client/host-transport.js";
-export { theoremConversationRequestSchema, theoremInvokeRequestSchema, theoremReplaySchema, theoremRewindRequestSchema, theoremStartRequestSchema, theoremSteerRequestSchema, theoremTurnRequestSchema, } from "../client/transport.js";
+export { theoremConversationRequestSchema, theoremInvokeRequestSchema, theoremReplaySchema, theoremRewindRequestSchema, theoremStartRequestSchema, theoremSteerRequestSchema, theoremStopRequestSchema, theoremTurnRequestSchema, } from "../client/transport.js";
 export { answerReply, conversationView, messageReply, openConversation, postedMessage, readerConversationHost, rewindConversation, startConversation, statelessRefusal, waitingCalls, } from "./conversation.js";
 export { createMemoryConversationStore, createSealedConversationStore, emptyConversation, storedConversationSchema, unknownConversation, } from "./conversation-store.js";
 export { createMemoryCredentialStore, } from "./credential-store.js";
@@ -20,6 +20,6 @@ export { sessionStateStore } from "./session-authority.js";
 export { createTheoremSessionBoundary, } from "./session-boundary.js";
 export { resolveSessionLimits } from "./session-limits.js";
 export { createMemorySessionStore, DEFAULT_OPERATION_RETENTION_MS, theoremSessionStateSchema, } from "./session-store.js";
-export { createMemorySteerInbox, steerStage, steerUnitOf, } from "./steer-inbox.js";
+export { createMemorySteerInbox, steerStage, steerUnitOf, stopOnRequest, } from "./steer-inbox.js";
 export { sessionToolCoordinator } from "./tool-operations.js";
 export { kernelTurnInput, liveSessionOpen } from "./turn-input.js";

package/server/steer-inbox.d.ts

@@ -1,6 +1,7 @@
 /**
  * Mid-turn steer inbox — the client posts user messages while a turn streams;
- * the turn's stage handler drains one unit per inject-capable stage.
+ * the turn's stage handler drains one unit per inject-capable stage. The
+ * client's stop reaches the turn through it too.
  *
  * @module
  */
@@ -21,8 +22,8 @@ export declare function steerUnitOf(steer: Pick<TheoremSteerRequest, 'id' | 'inj
 export declare function steerStage(inbox: SteerInbox, key: string): StageHandler;
 /**
  * Keyed by client turn id. The default lives in process memory, which is only
- * correct when steer POSTs reach the same process as the turn — swap in a
- * shared store (KV, Redis, Durable Object) for multi-instance hosts.
+ * correct when steer and stop POSTs reach the same process as the turn — swap
+ * in a shared store (KV, Redis, Durable Object) for multi-instance hosts.
  */
 export interface SteerInbox {
     open(turnId: string): void | Promise<void>;
@@ -30,6 +31,12 @@ export interface SteerInbox {
     enqueue(turnId: string, unit: SteerUnit): boolean | Promise<boolean>;
     /** Next unit, FIFO, or `undefined`. */
     consume(turnId: string): SteerUnit | undefined | Promise<SteerUnit | undefined>;
+    /** Stops the turn. Returns `false` when no turn with this id is open. */
+    stop(turnId: string): boolean | Promise<boolean>;
+    /** Settles `true` once the turn is stopped (at once if it already is), `false` once it closes. */
+    stopped(turnId: string): Promise<boolean>;
     close(turnId: string): void | Promise<void>;
 }
 export declare function createMemorySteerInbox(): SteerInbox;
+/** Aborts `stop` once the inbox's turn is stopped. */
+export declare function stopOnRequest(inbox: SteerInbox, turnId: string, stop: AbortController): void;

package/server/steer-inbox.js

@@ -1,6 +1,7 @@
 /**
  * Mid-turn steer inbox — the client posts user messages while a turn streams;
- * the turn's stage handler drains one unit per inject-capable stage.
+ * the turn's stage handler drains one unit per inject-capable stage. The
+ * client's stop reaches the turn through it too.
  *
  * @module
  */
@@ -29,24 +30,54 @@ export function steerStage(inbox, key) {
     };
 }
 export function createMemorySteerInbox() {
-    const queues = new Map();
+    const turns = new Map();
     return {
         open(turnId) {
-            if (!queues.has(turnId))
-                queues.set(turnId, []);
+            if (!turns.has(turnId))
+                turns.set(turnId, { queue: [], stopped: false, settle: new Set() });
         },
         enqueue(turnId, unit) {
-            const queue = queues.get(turnId);
-            if (!queue)
+            const turn = turns.get(turnId);
+            if (!turn)
                 return false;
-            queue.push(structuredClone(unit));
+            turn.queue.push(structuredClone(unit));
             return true;
         },
         consume(turnId) {
-            return queues.get(turnId)?.shift();
+            return turns.get(turnId)?.queue.shift();
+        },
+        stop(turnId) {
+            const turn = turns.get(turnId);
+            if (!turn)
+                return false;
+            turn.stopped = true;
+            for (const settle of turn.settle)
+                settle(true);
+            turn.settle.clear();
+            return true;
+        },
+        stopped(turnId) {
+            const turn = turns.get(turnId);
+            if (!turn)
+                return Promise.resolve(false);
+            if (turn.stopped)
+                return Promise.resolve(true);
+            return new Promise((resolve) => turn.settle.add(resolve));
         },
         close(turnId) {
-            queues.delete(turnId);
+            const turn = turns.get(turnId);
+            for (const settle of turn?.settle ?? [])
+                settle(false);
+            turns.delete(turnId);
         },
     };
 }
+/** Aborts `stop` once the inbox's turn is stopped. */
+export function stopOnRequest(inbox, turnId, stop) {
+    inbox.stopped(turnId).then((stopped) => {
+        if (stopped)
+            stop.abort();
+    }, 
+    // why: An inbox that can't say leaves the turn to run; the browser's fallback drops the stream.
+    () => { });
+}