slotlock 0.6.3 → 0.8.0

package/assistant.js

@@ -5,7 +5,9 @@
 // Nothing the model says changes the list of tools.
 //
 // Request formats as the vendors' official TypeScript SDKs describe them: @anthropic-ai/sdk 1.3.0
-// and openai 7.45.1 (read from the npm registry 2026-10-28).
+// and openai 7.45.1 (read from the npm registry 2026-10-28). Streamed answers as Anthropic's
+// "Streaming messages" page, the Chat Completions chunk object, @anthropic-ai/sdk 1.8.0 and openai
+// 7.55.0 describe them, read as server-sent events by the WHATWG HTML standard (all read 2026-11-10).
 //
 // The API key is sealed with AES-256-GCM (WebCrypto) under a key HKDF-SHA-256-derived from
 // SLOTLOCK_ASSISTANT_SECRET, with the tenant as additional data: a sealed key copied to another
@@ -34,6 +36,9 @@ export const SLOTLOCK_ASSISTANT_TOOL_USE = Object.freeze({
     slotlock_create_event: 'propose',
     slotlock_update_event: 'propose',
     slotlock_delete_event: 'propose',
+    slotlock_confirm_slot: 'propose',
+    slotlock_reschedule: 'propose',
+    slotlock_cancel: 'propose',
 });
 for (const [operation, use] of Object.entries(SLOTLOCK_ASSISTANT_TOOL_USE)) {
     // A read the assistant runs freely must be one the agent server calls a read.
@@ -56,6 +61,8 @@ export const SLOTLOCK_ASSISTANT_MAX_STORED_BYTES = 160_000;
 const MAX_ACTIONS_BYTES = 80_000;
 /** UTF-8 bytes of one proposed change's arguments as JSON; a larger one is not proposed. */
 export const SLOTLOCK_ASSISTANT_MAX_ACTION_BYTES = 16_000;
+/** Previous secrets a deployment may keep while keys are sealed again under its current one. */
+export const SLOTLOCK_ASSISTANT_MAX_PREVIOUS_SECRETS = 3;
 /** Proposed changes one conversation may have waiting at once (4 of the largest fit the bound). */
 export const SLOTLOCK_ASSISTANT_MAX_PENDING = 4;
 /** Characters of one tool result the model is shown. */
@@ -80,6 +87,7 @@ export function createSlotlockAssistantStore(store) {
             ...(actor !== undefined ? { updatedBy: actor } : {}),
         }), by(actor)),
         deleteSettings: (tenantRef, actor) => store.withTenant(tenantRef, (tenant) => tenant.deleteAssistantSettings({ tenantRef }), by(actor)),
+        resealKey: (tenantRef, from, to) => store.withTenant(tenantRef, (tenant) => tenant.resealAssistantKey({ tenantRef, from, to }), by(undefined)),
         // Each read deletes the tenant's expired conversations first, for deployments whose maintenance
         // never meets the tenant (a Worker's).
         getConversation: (tenantRef, memberRef) => store.withTenant(tenantRef, async (tenant) => {
@@ -133,6 +141,13 @@ export function createSlotlockMemoryAssistantStore(now = Date.now) {
         async deleteSettings(tenantRef) {
             return settings.delete(tenantRef);
         },
+        async resealKey(tenantRef, from, to) {
+            const stored = settings.get(tenantRef);
+            if (!stored || stored.sealedKey !== from || to.length === 0 || to === from)
+                return false;
+            settings.set(tenantRef, { ...stored, sealedKey: to });
+            return true;
+        },
         async getConversation(tenantRef, memberRef) {
             const found = live(tenantRef, memberRef);
             if (!found)
@@ -198,6 +213,19 @@ export async function sealSlotlockAssistantKey(secret, tenantRef, apiKey) {
     const sealed = await crypto.subtle.encrypt({ name: 'AES-GCM', iv, additionalData: boundTo(tenantRef) }, await sealingKey(secret), encoder.encode(apiKey));
     return `${SEAL_VERSION}.${Buffer.from(iv).toString('base64url')}.${Buffer.from(sealed).toString('base64url')}`;
 }
+/**
+ * The key a seal holds, tried with each secret in turn (the current one first, then
+ * SLOTLOCK_ASSISTANT_PREVIOUS_SECRETS), and which one opened it: 0 for the current secret. Null when
+ * none of them sealed it for this tenant.
+ */
+export async function openSlotlockAssistantKeyWithAny(secrets, tenantRef, sealed) {
+    for (const [secretIndex, secret] of secrets.entries()) {
+        const apiKey = await openSlotlockAssistantKey(secret, tenantRef, sealed);
+        if (apiKey !== null)
+            return { apiKey, secretIndex };
+    }
+    return null;
+}
 /** The key a seal holds, or null when it is not one this secret sealed for this tenant. */
 export async function openSlotlockAssistantKey(secret, tenantRef, sealed) {
     const [version, iv, body, ...rest] = sealed.split('.');
@@ -484,14 +512,279 @@ async function readBounded(response) {
     }
     return Buffer.concat(chunks).toString('utf8');
 }
+/** What an HTTP status from a model call means. */
+function statusReason(status) {
+    return status === 401 || status === 403
+        ? 'refused_key'
+        : status === 404
+            ? 'not_found'
+            : status === 429
+                ? 'rate_limited'
+                : status === 408 || status === 504
+                    ? 'timeout'
+                    : 'unavailable';
+}
+/** The HTTP status each Anthropic error type stands for ("Claude API errors"), for one sent mid-stream. */
+const ANTHROPIC_ERROR_STATUS = new Map([
+    ['invalid_request_error', 400],
+    ['authentication_error', 401],
+    ['billing_error', 402],
+    ['permission_error', 403],
+    ['not_found_error', 404],
+    ['request_too_large', 413],
+    ['rate_limit_error', 429],
+    ['api_error', 500],
+    ['timeout_error', 504],
+    ['overloaded_error', 529],
+]);
+/**
+ * Server-sent events as the WHATWG HTML standard interprets them: lines end at CRLF, LF or CR; a
+ * line starting with `:` is a comment; one space after the field's colon is dropped; `data` values
+ * join with LF; a blank line dispatches; other fields are ignored. Text comes in any pieces; an
+ * event the stream ends inside is never dispatched. `push` is true once `dispatch` was (stop).
+ */
+function sseLines(dispatch) {
+    let line = '';
+    let afterCR = false;
+    let event = '';
+    let data = '';
+    let done = false;
+    const take = (field) => {
+        if (field === '') {
+            if (data !== '')
+                done = dispatch(event || 'message', data.slice(0, -1));
+            event = '';
+            data = '';
+            return;
+        }
+        if (field.startsWith(':'))
+            return;
+        const colon = field.indexOf(':');
+        const name = colon === -1 ? field : field.slice(0, colon);
+        const value = colon === -1 ? '' : field.slice(field.charCodeAt(colon + 1) === 0x20 ? colon + 2 : colon + 1);
+        if (name === 'event')
+            event = value;
+        else if (name === 'data')
+            data += `${value}\n`;
+    };
+    return (text) => {
+        let start = 0;
+        for (let index = 0; index < text.length && !done; index += 1) {
+            const code = text.charCodeAt(index);
+            if (code === 0x0a && afterCR) {
+                // The LF of a CRLF whose CR ended the line, perhaps in the previous piece.
+                afterCR = false;
+                start = index + 1;
+                continue;
+            }
+            afterCR = code === 0x0d;
+            if (code !== 0x0a && code !== 0x0d)
+                continue;
+            take(line + text.slice(start, index));
+            line = '';
+            start = index + 1;
+        }
+        if (!done)
+            line += text.slice(start);
+        return done;
+    };
+}
+/**
+ * A streamed body, decoded as its bytes arrive (a character split across chunks waits for the
+ * rest) and read to `onEvent` until it answers true, within MAX_RESPONSE_BYTES. An abort cancels
+ * the read at once and is a timeout, even with events still in hand.
+ */
+async function readEvents(response, signal, onEvent) {
+    if (!response.body)
+        return;
+    const reader = response.body.getReader();
+    const cancel = () => {
+        reader.cancel().catch(() => undefined);
+    };
+    signal.addEventListener('abort', cancel, { once: true });
+    // UTF-8, without a leading byte order mark, as the standard decodes a stream.
+    const decoder = new TextDecoder();
+    const push = sseLines((event, data) => {
+        if (signal.aborted)
+            throw new SlotlockAssistantProviderError('timeout');
+        return onEvent(event, data);
+    });
+    let size = 0;
+    try {
+        for (;;) {
+            if (signal.aborted)
+                throw new SlotlockAssistantProviderError('timeout');
+            let chunk;
+            try {
+                chunk = await reader.read();
+            }
+            catch {
+                throw new SlotlockAssistantProviderError(signal.aborted ? 'timeout' : 'bad_answer');
+            }
+            if (chunk.done) {
+                if (signal.aborted)
+                    throw new SlotlockAssistantProviderError('timeout');
+                return;
+            }
+            size += chunk.value.byteLength;
+            if (size > MAX_RESPONSE_BYTES)
+                throw new SlotlockAssistantProviderError('bad_answer');
+            if (push(decoder.decode(chunk.value, { stream: true })))
+                return;
+        }
+    }
+    finally {
+        signal.removeEventListener('abort', cancel);
+        // Whatever follows the last event, or a body given up on, is not read.
+        cancel();
+    }
+}
+const parsedOr = (json, fallback) => {
+    try {
+        return JSON.parse(json);
+    }
+    catch {
+        return fallback;
+    }
+};
+/**
+ * An Anthropic stream: content blocks by index, text from `text_delta`s, a `tool_use`'s input from
+ * its `input_json_delta` fragments, parsed once whole; ended by `message_stop`. `ping` and event
+ * types this does not know are passed over; `error` names its error as an HTTP status would.
+ */
+function anthropicStream(emit) {
+    const blocks = new Map();
+    let stopped = false;
+    return {
+        event(name, data) {
+            const body = parsedOr(data, undefined);
+            if (name === 'error' || (isRecord(body) && body.type === 'error')) {
+                const type = isRecord(body) && isRecord(body.error) ? body.error.type : undefined;
+                const status = typeof type === 'string' ? ANTHROPIC_ERROR_STATUS.get(type) : undefined;
+                throw new SlotlockAssistantProviderError(status === undefined ? 'unavailable' : statusReason(status));
+            }
+            if (!isRecord(body)) {
+                if (name === 'ping')
+                    return false;
+                throw new SlotlockAssistantProviderError('bad_answer');
+            }
+            const index = typeof body.index === 'number' ? body.index : undefined;
+            if (body.type === 'content_block_start' && index !== undefined && isRecord(body.content_block)) {
+                const block = body.content_block;
+                if (block.type === 'text') {
+                    blocks.set(index, 'text');
+                    if (typeof block.text === 'string')
+                        emit(block.text);
+                }
+                else if (block.type === 'tool_use' && typeof block.id === 'string' && typeof block.name === 'string') {
+                    blocks.set(index, { id: block.id, name: block.name, input: block.input, json: '' });
+                }
+            }
+            else if (body.type === 'content_block_delta' && index !== undefined && isRecord(body.delta)) {
+                const block = blocks.get(index);
+                const delta = body.delta;
+                if (block === 'text' && delta.type === 'text_delta' && typeof delta.text === 'string')
+                    emit(delta.text);
+                if (typeof block === 'object' && delta.type === 'input_json_delta' && typeof delta.partial_json === 'string') {
+                    block.json += delta.partial_json;
+                }
+            }
+            else if (body.type === 'message_stop') {
+                stopped = true;
+            }
+            return stopped;
+        },
+        complete: () => stopped,
+        calls: () => [...blocks.entries()]
+            .sort(([a], [b]) => a - b)
+            .flatMap(([, block]) => block === 'text'
+            ? []
+            : [{ id: block.id, name: block.name, input: block.json === '' ? block.input : parsedOr(block.json, null) }]),
+    };
+}
+/**
+ * A Chat Completions stream: chunks whose first choice's delta carries `content` and `tool_calls`
+ * fragments, each call assembled by its `index` (id and name arrive once, arguments in pieces);
+ * complete at a `finish_reason`, ended by `data: [DONE]`. A chunk with an `error` is a failure.
+ */
+function openaiStream(emit) {
+    const slots = new Map();
+    let finished = false;
+    return {
+        event(name, data) {
+            if (data === '[DONE]') {
+                finished = true;
+                return true;
+            }
+            const body = parsedOr(data, undefined);
+            if (!isRecord(body))
+                throw new SlotlockAssistantProviderError('bad_answer');
+            if (name === 'error' || body.error)
+                throw new SlotlockAssistantProviderError('unavailable');
+            for (const choice of Array.isArray(body.choices) ? body.choices : []) {
+                if (!isRecord(choice) || (choice.index ?? 0) !== 0)
+                    continue;
+                const delta = isRecord(choice.delta) ? choice.delta : {};
+                if (typeof delta.content === 'string')
+                    emit(delta.content);
+                for (const [position, fragment] of (Array.isArray(delta.tool_calls) ? delta.tool_calls : []).entries()) {
+                    if (!isRecord(fragment))
+                        continue;
+                    // A server that sends whole calls without an index sends them in order.
+                    const index = typeof fragment.index === 'number' && Number.isSafeInteger(fragment.index) && fragment.index >= 0
+                        ? fragment.index
+                        : position;
+                    const slot = slots.get(index) ?? { args: '' };
+                    slots.set(index, slot);
+                    const fn = isRecord(fragment.function) ? fragment.function : {};
+                    if (typeof fragment.id === 'string' && fragment.id !== '')
+                        slot.id = fragment.id;
+                    if (typeof fn.name === 'string' && fn.name !== '')
+                        slot.name = fn.name;
+                    if (typeof fn.arguments === 'string')
+                        slot.args += fn.arguments;
+                }
+                if (typeof choice.finish_reason === 'string')
+                    finished = true;
+            }
+            return false;
+        },
+        complete: () => finished,
+        calls: () => [...slots.entries()]
+            .sort(([a], [b]) => a - b)
+            .flatMap(([index, slot]) => slot.name === undefined
+            ? []
+            : [{ id: slot.id ?? `call_${index}`, name: slot.name, input: parsedOr(slot.args || '{}', null) }]),
+    };
+}
+/** Text to `onText`, within MAX_MODEL_TEXT: what it was given is the answer's text. */
+function textSink(onText) {
+    let text = '';
+    return {
+        emit(delta) {
+            const kept = delta.slice(0, MAX_MODEL_TEXT - text.length);
+            if (kept === '')
+                return;
+            text += kept;
+            try {
+                onText(kept);
+            }
+            catch {
+                // Showing the answer never changes it.
+            }
+        },
+        text: () => text,
+    };
+}
+const isEventStream = (response) => (response.headers.get('content-type') ?? '').split(';')[0]?.trim().toLowerCase() === 'text/event-stream';
 /** One model call. Throws SlotlockAssistantProviderError, whose message never holds the key. */
 export async function callSlotlockAssistantModel(request) {
-    const { model } = request;
+    const { model, onText } = request;
     const anthropic = model.provider === 'anthropic';
     const url = anthropic ? `${model.baseUrl}/v1/messages` : `${model.baseUrl}/chat/completions`;
     const headers = {
         'content-type': 'application/json',
-        accept: 'application/json',
+        accept: onText ? 'text/event-stream' : 'application/json',
         'user-agent': 'slotlock-dashboard-assistant',
     };
     if (anthropic) {
@@ -502,12 +795,13 @@ export async function callSlotlockAssistantModel(request) {
     else if (model.apiKey) {
         headers.authorization = `Bearer ${model.apiKey}`;
     }
+    const body = anthropic ? anthropicBody(request) : openaiBody(request);
     let response;
     try {
         response = await request.fetch(url, {
             method: 'POST',
             headers,
-            body: JSON.stringify(anthropic ? anthropicBody(request) : openaiBody(request)),
+            body: JSON.stringify(onText ? { ...body, stream: true } : body),
             // Never follow a redirect: it would carry the key elsewhere.
             redirect: 'manual',
             signal: request.signal,
@@ -520,6 +814,90 @@ export async function callSlotlockAssistantModel(request) {
         }
         throw new SlotlockAssistantProviderError(name === 'TimeoutError' || name === 'AbortError' || request.signal.aborted ? 'timeout' : 'unavailable');
     }
+    if (!response.ok) {
+        await response.body?.cancel().catch(() => undefined);
+        throw new SlotlockAssistantProviderError(statusReason(response.status), response.status);
+    }
+    const sink = onText ? textSink(onText) : undefined;
+    if (sink && isEventStream(response)) {
+        const answer = anthropic ? anthropicStream(sink.emit) : openaiStream(sink.emit);
+        await readEvents(response, request.signal, answer.event);
+        if (!answer.complete())
+            throw new SlotlockAssistantProviderError('bad_answer');
+        return { text: sink.text(), calls: answer.calls() };
+    }
+    // One JSON answer: asked for, or sent by a server that does not stream.
+    let answer;
+    try {
+        answer = JSON.parse(await readBounded(response));
+    }
+    catch (error) {
+        if (error instanceof SlotlockAssistantProviderError)
+            throw error;
+        if (request.signal.aborted)
+            throw new SlotlockAssistantProviderError('timeout');
+        throw new SlotlockAssistantProviderError('bad_answer');
+    }
+    const turn = anthropic ? readAnthropic(answer) : readOpenai(answer);
+    sink?.emit(turn.text);
+    return { text: turn.text.slice(0, MAX_MODEL_TEXT), calls: turn.calls };
+}
+/**
+ * Providers the Settings form fills in (RFC 0003 A4): each one's API and the base URL it documents
+ * for it. Custom fills nothing, for any other OpenAI-compatible API. Choosing one saves nothing.
+ */
+export const SLOTLOCK_ASSISTANT_PRESETS = Object.freeze([
+    { id: 'anthropic', name: 'Anthropic', provider: 'anthropic', baseUrl: 'https://api.anthropic.com' },
+    { id: 'openai', name: 'OpenAI', provider: 'openai', baseUrl: 'https://api.openai.com/v1' },
+    { id: 'openrouter', name: 'OpenRouter', provider: 'openai', baseUrl: 'https://openrouter.ai/api/v1' },
+    {
+        id: 'google',
+        name: 'Google',
+        provider: 'openai',
+        baseUrl: 'https://generativelanguage.googleapis.com/v1beta/openai',
+    },
+    { id: 'mistral', name: 'Mistral', provider: 'openai', baseUrl: 'https://api.mistral.ai/v1' },
+    { id: 'groq', name: 'Groq', provider: 'openai', baseUrl: 'https://api.groq.com/openai/v1' },
+    { id: 'together', name: 'Together', provider: 'openai', baseUrl: 'https://api.together.xyz/v1' },
+    { id: 'custom', name: 'Custom', provider: 'openai', baseUrl: '' },
+]);
+/** Models one list keeps: a provider may offer hundreds. */
+const MAX_LISTED_MODELS = 500;
+/**
+ * The models a provider offers (`GET /v1/models` on the Anthropic API, `GET /models` on an
+ * OpenAI-compatible one, listed under `data` or as a bare array), by id, sorted, for the Settings
+ * form's Model field. Throws
+ * SlotlockAssistantProviderError as a model call does, never with the key in its message.
+ */
+export async function listSlotlockAssistantModels(args) {
+    const anthropic = args.provider === 'anthropic';
+    const headers = { accept: 'application/json', 'user-agent': 'slotlock-dashboard-assistant' };
+    if (anthropic) {
+        headers['anthropic-version'] = SLOTLOCK_ANTHROPIC_VERSION;
+        if (args.apiKey)
+            headers['x-api-key'] = args.apiKey;
+    }
+    else if (args.apiKey) {
+        headers.authorization = `Bearer ${args.apiKey}`;
+    }
+    const signal = AbortSignal.timeout(args.timeoutMs);
+    let response;
+    try {
+        response = await args.fetch(anthropic ? `${args.baseUrl}/v1/models?limit=1000` : `${args.baseUrl}/models`, {
+            method: 'GET',
+            headers,
+            // Never follow a redirect: it would carry the key elsewhere.
+            redirect: 'manual',
+            signal,
+        });
+    }
+    catch (error) {
+        const name = error?.name;
+        if (error?.code === 'private_address') {
+            throw new SlotlockAssistantProviderError('private_address');
+        }
+        throw new SlotlockAssistantProviderError(name === 'TimeoutError' || name === 'AbortError' || signal.aborted ? 'timeout' : 'unavailable');
+    }
     if (!response.ok) {
         await response.body?.cancel().catch(() => undefined);
         const status = response.status;
@@ -529,9 +907,7 @@ export async function callSlotlockAssistantModel(request) {
                 ? 'not_found'
                 : status === 429
                     ? 'rate_limited'
-                    : status === 408 || status === 504
-                        ? 'timeout'
-                        : 'unavailable', status);
+                    : 'unavailable', status);
     }
     let body;
     try {
@@ -540,12 +916,20 @@ export async function callSlotlockAssistantModel(request) {
     catch (error) {
         if (error instanceof SlotlockAssistantProviderError)
             throw error;
-        if (request.signal.aborted)
-            throw new SlotlockAssistantProviderError('timeout');
+        throw new SlotlockAssistantProviderError(signal.aborted ? 'timeout' : 'bad_answer');
+    }
+    // `{ data: [...] }` as OpenAI and Anthropic answer, or the bare array some OpenAI-compatible
+    // providers (Together) answer instead.
+    const listed = Array.isArray(body) ? body : isRecord(body) && Array.isArray(body.data) ? body.data : null;
+    if (!listed)
         throw new SlotlockAssistantProviderError('bad_answer');
+    const ids = new Set();
+    for (const entry of listed) {
+        const id = isRecord(entry) ? entry.id : undefined;
+        if (typeof id === 'string' && SLOTLOCK_ASSISTANT_MODEL_NAME.test(id))
+            ids.add(id);
     }
-    const turn = anthropic ? readAnthropic(body) : readOpenai(body);
-    return { text: turn.text.slice(0, MAX_MODEL_TEXT), calls: turn.calls };
+    return [...ids].sort().slice(0, MAX_LISTED_MODELS);
 }
 /**
  * The connection test: one request offering one read tool the model must call. True when it
@@ -577,16 +961,66 @@ const toolText = (value) => {
 /**
  * One member message: call the model, run what it reads, keep what it would write, and call it
  * again with the results, up to `maxSteps` calls. Only the offered tools run, whatever the model
- * names; everything else is answered `tool_not_available`.
+ * names; everything else is answered `tool_not_available`. With `onEvent` each model call streams;
+ * once `signal` aborts, no model call or tool goes on, and every call kept has its result.
  */
 export async function runSlotlockAssistantTurn(options) {
     const tools = slotlockAssistantTools();
     const byName = new Map(tools.map((tool) => [tool.name, tool]));
     const maxSteps = Math.max(1, Math.min(options.maxSteps ?? SLOTLOCK_ASSISTANT_MAX_STEPS, 20));
     const turnSignal = AbortSignal.timeout(options.turnTimeoutMs);
+    const { onEvent, signal: stop } = options;
     const added = [];
+    const tell = (event) => {
+        try {
+            onEvent?.(event);
+        }
+        catch {
+            // Showing the turn never changes it.
+        }
+    };
+    const stopped = () => {
+        added.push({ role: 'note', text: 'Stopped.' });
+        return { added };
+    };
+    const run = async (call, tool, index) => {
+        if (!tool || index >= MAX_CALLS_PER_STEP) {
+            return {
+                id: call.id,
+                name: call.name,
+                content: toolText({ error: { code: tool ? 'too_many_calls' : 'tool_not_available' } }),
+                error: true,
+            };
+        }
+        if (tool.use === 'read') {
+            const outcome = await options.read(tool.name, call.input);
+            return {
+                id: call.id,
+                name: call.name,
+                content: toolText(outcome.ok ? outcome.data : { error: { code: outcome.code, ...(outcome.details ?? {}) } }),
+                error: !outcome.ok,
+            };
+        }
+        const proposed = await options.propose(tool.name, call.input);
+        return proposed.ok
+            ? {
+                id: call.id,
+                name: call.name,
+                content: toolText({
+                    status: 'proposed',
+                    action_id: proposed.actionId,
+                    note: 'Not run. The member sees this change and may approve it; the result comes back as a dashboard note.',
+                }),
+                error: false,
+                action: proposed.actionId,
+            }
+            : { id: call.id, name: call.name, content: toolText({ error: { code: proposed.code } }), error: true };
+    };
     for (let step = 0; step < maxSteps; step += 1) {
+        if (stop?.aborted)
+            return stopped();
         let turn;
+        let streamed = '';
         try {
             turn = await callSlotlockAssistantModel({
                 model: options.model,
@@ -594,10 +1028,24 @@ export async function runSlotlockAssistantTurn(options) {
                 entries: [...options.entries, ...added],
                 tools,
                 fetch: options.fetch,
-                signal: AbortSignal.any([turnSignal, AbortSignal.timeout(options.timeoutMs)]),
+                signal: AbortSignal.any([turnSignal, AbortSignal.timeout(options.timeoutMs), ...(stop ? [stop] : [])]),
+                ...(onEvent
+                    ? {
+                        onText: (delta) => {
+                            streamed += delta;
+                            tell({ type: 'text', delta });
+                        },
+                    }
+                    : {}),
             });
         }
         catch (error) {
+            if (stop?.aborted) {
+                // The text shown so far stays; calls of a reply cut short do not, as none has a result.
+                if (streamed !== '')
+                    added.push({ role: 'assistant', text: streamed, calls: [] });
+                return stopped();
+            }
             added.push({ role: 'note', text: slotlockAssistantProviderMessage(error) });
             return { added, failure: error };
         }
@@ -611,48 +1059,28 @@ export async function runSlotlockAssistantTurn(options) {
             return { added };
         const results = [];
         for (const [index, call] of calls.entries()) {
-            const tool = byName.get(call.name);
-            if (!tool || index >= MAX_CALLS_PER_STEP) {
-                results.push({
-                    id: call.id,
-                    name: call.name,
-                    content: toolText({ error: { code: tool ? 'too_many_calls' : 'tool_not_available' } }),
-                    error: true,
-                });
-                continue;
-            }
-            if (tool.use === 'read') {
-                const outcome = await options.read(tool.name, call.input);
-                results.push({
-                    id: call.id,
-                    name: call.name,
-                    content: toolText(outcome.ok ? outcome.data : { error: { code: outcome.code, ...(outcome.details ?? {}) } }),
-                    error: !outcome.ok,
-                });
+            if (stop?.aborted) {
+                // Not run: answered, so the model is never sent a call without its result.
+                results.push({ id: call.id, name: call.name, content: toolText({ error: { code: 'stopped' } }), error: true });
                 continue;
             }
-            const proposed = await options.propose(tool.name, call.input);
-            results.push(proposed.ok
-                ? {
-                    id: call.id,
-                    name: call.name,
-                    content: toolText({
-                        status: 'proposed',
-                        action_id: proposed.actionId,
-                        note: 'Not run. The member sees this change and may approve it; the result comes back as a dashboard note.',
-                    }),
-                    error: false,
-                    action: proposed.actionId,
-                }
-                : {
-                    id: call.id,
-                    name: call.name,
-                    content: toolText({ error: { code: proposed.code } }),
-                    error: true,
-                });
+            const tool = byName.get(call.name);
+            const use = !tool ? 'unknown' : tool.use === 'read' ? 'read' : 'write';
+            tell({ type: 'call', id: call.id, name: call.name, use });
+            const result = await run(call, tool, index);
+            results.push(result);
+            tell({
+                type: 'result',
+                id: result.id,
+                name: result.name,
+                ok: !result.error,
+                ...(result.action !== undefined ? { actionId: result.action } : {}),
+            });
         }
         added.push({ role: 'tool', results });
     }
+    if (stop?.aborted)
+        return stopped();
     added.push({
         role: 'note',
         text: `The assistant stopped after ${maxSteps} steps. Ask again, or more narrowly, to go on.`,