@agentshouse/kit 0.2.1-cde47fd72fe59 → 0.2.1-ce3d2bb67177c

package/dist/conversations.js

@@ -4,15 +4,16 @@ import { mkdir } from 'node:fs/promises';
 import { join } from 'node:path';
 import { unlessAborted } from './abort.js';
 import { startAdapter } from './acp.js';
-import { finalRefusal } from './api.js';
+import { finalRefusal, HouseRefusal } from './api.js';
 import { openBridge } from './bridge.js';
 import { CLIS } from './clis.js';
 import { answeredFailure, readerFor } from './events.js';
-import { placeFiles, uploadBytes } from './files.js';
+import { inspectedFile, linkedPaths, storeRefusal, uploaded } from './files.js';
 import { agentBase } from './home.js';
 import { instructions } from './instructions.js';
 import { Parts } from './parts.js';
 import { refusalOf } from './refusals.js';
+import { relayed } from './relay.js';
 import { killMarked, Scope } from './scope.js';
 import { holdSecretInput } from './secret-input.js';
 import { createHowWeWork } from './skills.js';
@@ -20,6 +21,7 @@ import { transcribe } from './transcription.js';
 import { workFor } from './work.js';
 const SIGNED_OUT = RequestError.authRequired().code;
 const KILLED = 'the conversation was killed';
+const INTERRUPTED = 'the conversation was interrupted';
 const REFUSED = 'the CLI refused the prompt';
 const NO_CONNECTION = "the Agent's computer could not open this conversation; try again";
 const GONE = 'House no longer holds this conversation; start a new one';
@@ -31,9 +33,12 @@ const ENDED = {
 const NO_START = "the Agent's CLI did not start";
 const NO_SESSION = "the Agent's CLI did not open a session";
 const NO_RESUME = "the Agent's CLI could not resume this conversation";
+const NOT_SIGNED_IN = "the Agent's CLI is not signed in; sign it in on the Agent's machine";
 const NO_SETTINGS = "the Agent's CLI refused the Agent's model, mode or effort";
 class NotStarted extends Error {
 }
+class ResumeRefused extends NotStarted {
+}
 async function step(reason, work) {
     try {
         return await work;
@@ -42,6 +47,14 @@ async function step(reason, work) {
         throw new NotStarted(typeof reason === 'string' ? reason : reason(error), { cause: error });
     }
 }
+function signedOut(error) {
+    return typeof error === 'object' && error !== null && error.code === SIGNED_OUT;
+}
+function unopened(reason) {
+    return (error) => (signedOut(error) ? NOT_SIGNED_IN : reason);
+}
+// A start-up step is shown only once it has lasted a second, so a quick start shows none of them.
+const STARTING_SHOWN_AFTER_MS = 1_000;
 function unbridged(error) {
     return (finalRefusal(error) ? ENDED[refusalOf(error.text)?.code ?? ''] : undefined) ?? NO_CONNECTION;
 }
@@ -53,13 +66,12 @@ const EXIT_PLAN_MODE = {
         return value;
     },
 };
-export const CONVERSATION_INPUTS = new Set(['open', 'message', 'interrupt', 'kill', 'option', 'answer']);
+export const CONVERSATION_METHODS = new Set(['open', 'message', 'interrupt', 'kill', 'option', 'answer']);
 function causeOf(error) {
     return error instanceof Error ? error.message : String(error);
 }
 function answeredWith(error) {
-    const signedOut = typeof error === 'object' && error !== null && error.code === SIGNED_OUT;
-    return { failure: signedOut ? 'signed_out' : 'error', cause: causeOf(error) };
+    return { failure: signedOut(error) ? 'signed_out' : 'error', cause: causeOf(error) };
 }
 function exitedWith(running, cause) {
     return running.killed ? { failure: 'killed', cause: KILLED } : { failure: 'exited', cause };
@@ -67,16 +79,28 @@ function exitedWith(running, cause) {
 function answerMessage(request, response) {
     return `The User answered a question you asked earlier.\nQuestion: ${JSON.stringify(request)}\nAnswer: ${JSON.stringify(response)}`;
 }
+async function sentPart(url, bytes) {
+    const answer = await fetch(relayed(url), { method: 'PUT', body: bytes });
+    await answer.arrayBuffer();
+    if (!answer.ok)
+        throw storeRefusal('upload', answer.status);
+}
 function logged(error) {
     process.stderr.write(`kit: ${causeOf(error)}\n`);
 }
 function refusal(conversation, error) {
     if (conversation.kills > 0)
         return KILLED;
-    const cause = error instanceof NotStarted ? `${error.message}: ${causeOf(error.cause)}` : causeOf(error);
+    const cause = error instanceof Error && error.cause !== undefined ? `${error.message}: ${causeOf(error.cause)}` : causeOf(error);
     logged(new Error(`conversation ${conversation.id} did not start: ${cause}`));
     return causeOf(error);
 }
+function audioOf(result) {
+    if (result.isError === true)
+        return null;
+    const file = inspectedFile(result.content.map((content) => content.text).join('\n'));
+    return file?.media_type?.startsWith('audio/') === true ? file : null;
+}
 function marker(bridge) {
     return `HOUSE_BRIDGE=${bridge.env.HOUSE_BRIDGE}`;
 }
@@ -86,6 +110,7 @@ class Turn {
     questions = 0;
     secrets = 0;
     prompted = false;
+    taken = null;
     ended = false;
     images = 0;
     uploads = [];
@@ -99,6 +124,8 @@ class Conversation {
     session = null;
     turn = null;
     commands = null;
+    options = null;
+    exitUntold = false;
     context = null;
     leftovers = new Set();
     waiting = [];
@@ -106,6 +133,8 @@ class Conversation {
     subagents = new Map();
     held = [];
     opening = null;
+    bridge = null;
+    launch = null;
     prompted = null;
     kills = 0;
     killed = new AbortController();
@@ -114,6 +143,11 @@ class Conversation {
     open = 0;
     queue = Promise.resolve();
     reports = Promise.resolve();
+    starting = null;
+    preparing = null;
+    told = null;
+    untold = false;
+    shown = null;
     constructor(id) {
         this.id = id;
     }
@@ -137,23 +171,23 @@ export class Conversations {
         // A process or a durable schedule ends without a report, so the Kit looks at both again every two seconds.
         setInterval(() => this.look(), 2_000);
     }
-    input(input) {
-        void this.kit.inputs.carry(input.input_id, () => {
-            const conversation = this.conversation(input.conversation_id);
-            if (input.kind === 'kill') {
+    call(call) {
+        void this.kit.calls.carry(call.input_id, () => {
+            const conversation = this.conversation(call.conversation_id);
+            if (call.kind === 'kill') {
                 conversation.kills++;
                 conversation.killed.abort(new Error(KILLED));
                 for (const waiting of conversation.waiting.splice(0))
                     waiting.settle({ refused: KILLED });
                 this.halt(conversation);
             }
-            if (input.kind === 'interrupt') {
+            if (call.kind === 'interrupt') {
                 conversation.interrupts++;
                 conversation.interrupted.abort();
             }
-            const handled = conversation.queue.then(() => this.carry(conversation, input));
+            const handled = conversation.queue.then(() => this.carry(conversation, call));
             conversation.queue = handled.catch(() => undefined);
-            return handled.then(async ({ ack }) => ({ ack: await ack }));
+            return handled.then(async ({ result }) => ({ result: await result }));
         });
     }
     idle() {
@@ -186,6 +220,14 @@ export class Conversations {
     }
     opened() {
         this.watched = false;
+        for (const conversation of this.conversations.values()) {
+            if (conversation.running !== null)
+                this.facts(conversation);
+            else if (conversation.exitUntold)
+                this.process(conversation, false);
+            if (conversation.untold || conversation.told !== null)
+                this.retell(conversation);
+        }
     }
     watching(watched) {
         const resend = watched && !this.watched;
@@ -205,63 +247,99 @@ export class Conversations {
         }
         return conversation;
     }
-    async carry(conversation, input) {
-        if (input.kind === 'open')
-            return { ack: Promise.resolve(await this.open(conversation, input)) };
-        if (input.kind === 'message')
-            return this.message(conversation, input);
-        if (input.kind === 'interrupt') {
+    async carry(conversation, call) {
+        if (call.kind === 'open')
+            return { result: this.open(conversation, call) };
+        if (call.kind === 'message')
+            return this.message(conversation, call);
+        await this.launched(conversation);
+        if (call.kind === 'interrupt') {
             if (--conversation.interrupts === 0)
                 conversation.interrupted = new AbortController();
-            await this.interrupt(conversation, String(input.turn_id));
+            await this.interrupt(conversation, String(call.turn_id));
         }
-        if (input.kind === 'kill') {
+        if (call.kind === 'kill') {
             await this.kill(conversation);
             await conversation.sending;
             if (--conversation.kills === 0)
                 conversation.killed = new AbortController();
         }
-        if (input.kind === 'option')
-            await this.option(conversation, String(input.option), input.value);
-        if (input.kind === 'answer') {
-            const question = this.questions.get(String(input.interaction_id));
+        if (call.kind === 'option')
+            await this.option(conversation, String(call.option), call.value);
+        if (call.kind === 'answer') {
+            const question = this.questions.get(String(call.interaction_id));
             if (question === undefined) {
-                const text = answerMessage(input.request, input.response);
-                return this.message(conversation, { ...input, text, files: [], first: false });
+                const text = answerMessage(call.request, call.response);
+                return this.message(conversation, { ...call, text, first: false, message_id: null });
             }
-            question.answer(input.response);
+            question.answer(call.response);
         }
-        return { ack: Promise.resolve({}) };
+        return { result: Promise.resolve({}) };
     }
-    async open(conversation, input) {
+    open(conversation, call) {
         if (conversation.running !== null)
-            return {};
-        try {
-            return { provider_session_id: await this.start(conversation, await this.route(conversation, input.agent_id), null, true) };
-        }
-        catch (error) {
-            return { refused: refusal(conversation, error) };
-        }
+            return Promise.resolve({});
+        const launch = conversation.launch ?? this.launch(conversation, this.route(conversation, call.agent_id), null, true);
+        return launch.session.then((session) => ({ provider_session_id: session }), (error) => ({ refused: refusal(conversation, error) }));
+    }
+    launch(conversation, route, sessionId, empty) {
+        let opened;
+        let failed;
+        const bridge = new Promise((resolve, reject) => {
+            opened = resolve;
+            failed = reject;
+        });
+        bridge.catch(() => undefined);
+        const session = this.start(conversation, route, sessionId, empty, opened);
+        session.catch(failed);
+        const launch = { bridge, session };
+        conversation.launch = launch;
+        void session
+            .catch(() => undefined)
+            .then(() => {
+            if (conversation.launch !== launch)
+                return;
+            conversation.launch = null;
+            this.closeIdleBridge(conversation);
+            this.next(conversation);
+        });
+        this.next(conversation);
+        return launch;
     }
-    async message(conversation, input) {
-        const content = [{ type: 'text', text: String(input.text) }];
+    async launched(conversation) {
+        while (conversation.launch !== null)
+            await conversation.launch.session.catch(() => undefined);
+    }
+    instructed(conversation, route) {
+        const bridge = conversation.running === null ? conversation.launch?.bridge : Promise.resolve(conversation.running.bridge);
+        if (bridge === undefined)
+            return null;
+        const read = Promise.all([bridge, this.kit.copies.mapping()]).then(([opened, copies]) => instructions(opened, route.base_instructions, copies));
+        read.catch(() => undefined);
+        return read;
+    }
+    async message(conversation, call) {
+        const content = [{ type: 'text', text: String(call.text) }];
         let route;
+        let instructing = null;
         try {
-            route = await this.route(conversation, input.agent_id);
-            const files = input.files;
-            const paths = await placeFiles(this.kit.house, route.working_directory, files, conversation.killed.signal);
-            const lines = await this.transcribed(conversation, files, paths);
-            if (lines.length > 0)
-                content.push({ type: 'text', text: lines.join('\n') });
+            route = await this.route(conversation, call.agent_id);
+            if (call.first === true)
+                instructing = this.instructed(conversation, route);
+            if (call.message_id !== null)
+                content.push(...(await this.transcribed(conversation, String(call.message_id), String(call.text))));
             if (conversation.kills > 0)
                 throw new Error(KILLED);
         }
         catch (error) {
-            return { ack: Promise.resolve({ refused: refusal(conversation, error) }) };
+            this.closeIdleBridge(conversation);
+            this.prepares(conversation, null);
+            return { result: Promise.resolve({ refused: refusal(conversation, error) }) };
         }
+        conversation.preparing = null;
         return {
-            ack: new Promise((settle) => {
-                conversation.waiting.push({ input, route, content, settle });
+            result: new Promise((settle) => {
+                conversation.waiting.push({ call, route, content, instructing, settle });
                 this.next(conversation);
             }),
         };
@@ -270,66 +348,148 @@ export class Conversations {
         if (conversation.sending !== null || conversation.open > 0)
             return;
         const waiting = conversation.waiting.shift();
-        if (waiting === undefined)
+        if (waiting === undefined) {
+            const step = conversation.preparing ?? (conversation.launch === null ? null : 'session');
+            if (conversation.starting !== step)
+                this.starts(conversation, step);
             return;
+        }
         conversation.sending = this.send(conversation, waiting).finally(() => {
             conversation.sending = null;
             this.next(conversation);
         });
     }
     async send(conversation, waiting) {
-        const { input } = waiting;
-        let ack = {};
+        const { call } = waiting;
+        let result = {};
         let started = false;
+        let instructing = waiting.instructing;
         const prompt = [];
         try {
             if (conversation.running === null) {
-                const stored = conversation.session ?? input.provider_session_id;
-                const empty = input.first === true && conversation.prompted !== stored;
-                started = (await this.start(conversation, waiting.route, stored, empty)) !== stored;
+                this.starts(conversation, 'session');
+                await this.launched(conversation);
+            }
+            if (conversation.running === null) {
+                const stored = conversation.session ?? call.provider_session_id;
+                const empty = call.first === true && conversation.prompted !== stored;
+                const launch = this.launch(conversation, Promise.resolve(waiting.route), stored, empty);
+                if (call.first === true)
+                    instructing = this.instructed(conversation, waiting.route);
+                started = (await launch.session) !== stored;
             }
             const session = conversation.running.sessionId;
-            if (started || (input.first === true && session !== input.provider_session_id)) {
-                ack = { provider_session_id: session };
+            if (started || (call.first === true && session !== call.provider_session_id)) {
+                result = { provider_session_id: session };
             }
-            if (input.first === true) {
-                prompt.push({
-                    type: 'text',
-                    text: await instructions(conversation.running.bridge, waiting.route.base_instructions, await this.kit.copies.mapping()),
-                });
+            if (call.first === true) {
+                prompt.push({ type: 'text', text: await (instructing ?? this.instructed(conversation, waiting.route)) });
             }
             if (conversation.kills > 0)
                 throw new Error(KILLED);
         }
         catch (error) {
+            this.starts(conversation, null);
             if (started) {
                 conversation.session = null;
                 await this.kill(conversation);
             }
-            waiting.settle({ refused: refusal(conversation, error) });
+            const refused = refusal(conversation, error);
+            const resumeRefused = call.kind === 'message' && conversation.kills === 0 && error instanceof ResumeRefused;
+            waiting.settle(resumeRefused ? { refused, resume_refused: true } : { refused });
+            return;
+        }
+        this.starts(conversation, null);
+        this.prompt(conversation, [...prompt, ...waiting.content], () => this.kit.calls.keepResult(String(call.input_id), result));
+        waiting.settle(result);
+    }
+    starts(conversation, step) {
+        conversation.starting = step;
+        if (conversation.shown !== null)
+            clearTimeout(conversation.shown);
+        conversation.shown = null;
+        if (step === null || conversation.told !== null) {
+            this.tell(conversation, step);
             return;
         }
-        this.prompt(conversation, [...prompt, ...waiting.content]);
-        waiting.settle(ack);
+        conversation.shown = setTimeout(() => {
+            conversation.shown = null;
+            if (conversation.starting === step)
+                this.tell(conversation, step);
+        }, STARTING_SHOWN_AFTER_MS);
     }
-    async transcribed(conversation, files, paths) {
-        const lines = [];
-        for (const [index, path] of paths.entries()) {
-            lines.push(path);
-            if (files[index].media_type?.startsWith('audio/') !== true)
-                continue;
-            try {
-                const text = await transcribe(path, AbortSignal.any([conversation.killed.signal, conversation.interrupted.signal]));
-                if (text !== null && text !== '')
-                    lines.push(`Transcript: ${text}`);
-            }
-            catch (error) {
-                if (conversation.kills > 0)
-                    throw error;
-                logged(new Error(`${files[index].name} was not transcribed: ${causeOf(error)}`));
+    prepares(conversation, step) {
+        conversation.preparing = step;
+        this.next(conversation);
+    }
+    tell(conversation, step) {
+        if (conversation.told === step && !conversation.untold)
+            return;
+        conversation.told = step;
+        this.retell(conversation);
+    }
+    retell(conversation) {
+        conversation.untold = !this.kit.send({ type: 'starting', conversation_id: conversation.id, step: conversation.told });
+    }
+    async transcribed(conversation, messageId, text) {
+        const paths = linkedPaths(text);
+        if (paths.length === 0)
+            return [];
+        const killed = conversation.killed.signal;
+        const interrupted = conversation.interrupted.signal;
+        const transcribing = AbortSignal.any([killed, interrupted]);
+        let signal = killed;
+        const blocks = [];
+        try {
+            const bridge = await step(unbridged, unlessAborted(this.bridged(conversation), killed));
+            const read = async (path) => audioOf(await step(unbridged, unlessAborted(bridge.tool('inspect', { path }), signal)));
+            for (const path of paths) {
+                let answered = await read(path);
+                if (answered === null)
+                    continue;
+                signal = transcribing;
+                this.prepares(conversation, 'transcription');
+                const said = await transcribe(async () => {
+                    const address = answered ?? (await read(path));
+                    answered = null;
+                    if (address === null)
+                        throw new Error(`${path} is no longer an audio file`);
+                    return address;
+                }, signal);
+                const transcript = `/kit/conversations/${conversation.id}/messages/${messageId}/transcripts`;
+                await step(unbridged, unlessAborted(this.kit.house.deliver(transcript, { path, text: said }, () => !signal.aborted), signal));
+                blocks.push({ type: 'text', text: `${path}\nTranscript: ${said}` });
             }
         }
-        return lines;
+        catch (error) {
+            if (signal === transcribing && interrupted.aborted && conversation.kills === 0)
+                throw new NotStarted(INTERRUPTED, { cause: error });
+            throw error;
+        }
+        return blocks;
+    }
+    bridged(conversation) {
+        if (conversation.bridge === null) {
+            const bridging = openBridge(this.kit.house, this.kit.copies, conversation.id, conversation.killed.signal);
+            conversation.bridge = bridging;
+            bridging.catch(() => {
+                if (conversation.bridge === bridging)
+                    conversation.bridge = null;
+            });
+        }
+        return conversation.bridge;
+    }
+    closeBridge(conversation, bridging, bridge) {
+        bridge.close();
+        if (conversation.bridge === bridging)
+            conversation.bridge = null;
+    }
+    closeIdleBridge(conversation) {
+        const bridging = conversation.bridge;
+        if (bridging === null || conversation.running !== null || conversation.launch !== null)
+            return;
+        conversation.bridge = null;
+        void bridging.then((bridge) => bridge.close(), () => undefined);
     }
     async interrupt(conversation, turnId) {
         if (conversation.running === null || conversation.turn?.id !== turnId)
@@ -384,7 +544,8 @@ export class Conversations {
         }
         return route;
     }
-    async start(conversation, route, sessionId, empty) {
+    async start(conversation, routed, sessionId, empty, bridged) {
+        const route = await routed;
         const reader = readerFor(route.kind);
         reader.session = sessionId;
         const app = client({ name: '@agentshouse/kit' })
@@ -392,9 +553,10 @@ export class Conversations {
             .onRequest('elicitation/create', ({ params, signal }) => this.ask(conversation, 'elicitation/create', params, asksSecret(params), signal))
             .onRequest('_x.ai/exit_plan_mode', EXIT_PLAN_MODE, ({ params, signal }) => this.ask(conversation, '_x.ai/exit_plan_mode', params, false, signal));
         const cli = await unlessAborted(this.kit.agents.cli(route.kind), conversation.killed.signal);
-        const bridge = await step(unbridged, openBridge(this.kit.house, this.kit.copies, conversation.id, conversation.killed.signal));
+        const bridging = this.bridged(conversation);
+        const bridge = await step(unbridged, bridging);
         if (conversation.kills > 0) {
-            bridge.close();
+            this.closeBridge(conversation, bridging, bridge);
             throw new Error(KILLED);
         }
         conversation.opening = bridge;
@@ -403,32 +565,31 @@ export class Conversations {
         let adapter = null;
         try {
             await unlessAborted(createHowWeWork(bridge), conversation.killed.signal);
+            bridged(bridge);
             await CLIS[route.kind].allowHouse(bridge.env.PATH);
             const streamed = await step(NO_CONNECTION, work.open(cli));
             adapter = await step(NO_START, startAdapter(route.kind, cli, route.working_directory, app, (message) => {
                 work.read(message);
                 this.read(conversation, reader, message);
             }, { ...bridge.env, ...streamed }, undefined, scope));
-            void adapter.exited.then(() => bridge.close());
+            void adapter.exited.then(() => this.closeBridge(conversation, bridging, bridge));
             const agent = adapter.connection.agent;
             const cwd = route.working_directory;
             const _meta = CLIS[route.kind].sessionMeta(bridge.env.HOUSE_BRIDGE, conversation.id);
             const resumed = sessionId === null ? null : await this.resume(conversation, route.kind, adapter, { sessionId, cwd, mcpServers: [], _meta }, empty);
-            const opened = resumed ?? (await step(NO_SESSION, agent.request('session/new', { cwd, mcpServers: [], _meta })));
+            const opened = resumed ?? (await step(unopened(NO_SESSION), agent.request('session/new', { cwd, mcpServers: [], _meta })));
             reader.session = opened.sessionId;
             if (opened.sessionId !== sessionId && CLIS[route.kind].renames) {
                 const prompt = [{ type: 'text', text: `/rename ${conversation.id}` }];
-                await step(NO_SESSION, agent.request('session/prompt', { sessionId: opened.sessionId, prompt }));
+                await step(unopened(NO_SESSION), agent.request('session/prompt', { sessionId: opened.sessionId, prompt }));
             }
-            const running = { adapter, bridge, sessionId: opened.sessionId, killed: false, reader, work, scope };
+            const running = { adapter, bridging, bridge, sessionId: opened.sessionId, killed: false, reader, work, scope };
             const options = await step(NO_SETTINGS, this.launchSettings(running, route, opened.configOptions ?? []));
             void work.settled().then(() => scope.record());
             conversation.running = running;
             conversation.session = running.sessionId;
-            this.kit.send({ type: 'process', conversation_id: conversation.id, running: true });
-            if (conversation.commands !== null)
-                this.commands(conversation, conversation.commands);
-            this.options(conversation, options);
+            conversation.options = options;
+            this.facts(conversation);
             void adapter.lost.then((cause) => this.exited(conversation, running, cause));
             return running.sessionId;
         }
@@ -436,7 +597,7 @@ export class Conversations {
             adapter?.retire();
             work.close();
             conversation.leftovers.add(scope);
-            bridge.close();
+            this.closeBridge(conversation, bridging, bridge);
             throw conversation.kills > 0 ? new Error(KILLED) : error;
         }
         finally {
@@ -449,7 +610,7 @@ export class Conversations {
         }
         catch (error) {
             if (!empty || conversation.kills > 0 || !CLIS[kind].unknownSession(error)) {
-                throw new NotStarted(NO_RESUME, { cause: error });
+                throw signedOut(error) ? new NotStarted(NOT_SIGNED_IN, { cause: error }) : new ResumeRefused(NO_RESUME, { cause: error });
             }
             logged(new Error(`conversation ${conversation.id} opens a new session: ${NO_RESUME}: ${causeOf(error)}`));
             return null;
@@ -485,15 +646,28 @@ export class Conversations {
         this.kit.changed();
     }
     detach(conversation, running) {
+        if (conversation.bridge === running.bridging)
+            conversation.bridge = null;
         running.work.close();
         conversation.leftovers.add(running.scope);
         conversation.running = null;
         conversation.commands = null;
+        conversation.options = null;
         for (const [id, question] of this.questions) {
             if (question.conversation === conversation)
                 this.questions.delete(id);
         }
-        this.kit.send({ type: 'process', conversation_id: conversation.id, running: false });
+        this.process(conversation, false);
+    }
+    process(conversation, running) {
+        conversation.exitUntold = !this.kit.send({ type: 'process', conversation_id: conversation.id, running }) && !running;
+    }
+    facts(conversation) {
+        this.process(conversation, true);
+        if (conversation.commands !== null)
+            this.commands(conversation, conversation.commands);
+        if (conversation.options !== null)
+            this.options(conversation, conversation.options);
     }
     commands(conversation, commands) {
         conversation.commands = commands;
@@ -504,6 +678,7 @@ export class Conversations {
     options(conversation, options) {
         if (conversation.running === null)
             return;
+        conversation.options = options;
         this.kit.send({ type: 'options', conversation_id: conversation.id, options });
     }
     deliver(conversation, turn, event, body) {
@@ -562,12 +737,14 @@ export class Conversations {
         this.next(conversation);
         this.kit.changed();
     }
-    prompt(conversation, prompt) {
+    prompt(conversation, prompt, taken) {
         const running = conversation.running;
         const turn = this.begin(conversation);
         turn.prompted = true;
+        turn.taken = taken;
         conversation.prompted = running.sessionId;
         running.adapter.connection.agent.request('session/prompt', { sessionId: running.sessionId, prompt }).then((answer) => {
+            this.took(turn);
             const notice = answeredFailure(answer);
             if (notice !== null) {
                 this.end(conversation, turn, { failure: notice.limit ? 'limit' : 'error', cause: notice.title }, notice.title);
@@ -580,6 +757,7 @@ export class Conversations {
                 this.end(conversation, turn, exitedWith(running, await running.adapter.exited));
             }
             else {
+                this.took(turn);
                 if (conversation.open === 1 && conversation.running === running) {
                     running.adapter.retire();
                     this.detach(conversation, running);
@@ -589,7 +767,9 @@ export class Conversations {
         });
     }
     started(conversation) {
-        return conversation.turn ?? this.begin(conversation);
+        const turn = conversation.turn ?? this.begin(conversation);
+        this.took(turn);
+        return turn;
     }
     ended(conversation) {
         const turn = conversation.turn;
@@ -684,6 +864,11 @@ export class Conversations {
         }
         this.apply(conversation, this.started(conversation), event);
     }
+    took(turn) {
+        const taken = turn.taken;
+        turn.taken = null;
+        taken?.();
+    }
     apply(conversation, turn, event) {
         switch (event.kind) {
             case 'text':
@@ -738,13 +923,16 @@ export class Conversations {
                 bytes: bytes.length,
                 sha256: createHash('sha256').update(bytes).digest('hex'),
             }));
-            const saved = declared.upload === undefined ? declared : await uploadBytes(declared.upload, bytes);
-            if (saved.save.status !== 'saved')
-                throw new Error(saved.save.failure ?? saved.save.status);
-            turn.parts.arrive({ type: 'image', file: saved.version, name, media_type: mediaType }, reserved);
+            const saved = await uploaded(declared.upload, {
+                bytes: bytes.length,
+                send: (url, start, end) => sentPart(url, bytes.subarray(start, end)),
+                finish: (upload) => this.kit.house.deliver('/kit/uploads/finish', { upload }),
+            });
+            turn.parts.arrive({ type: 'image', file: saved.path, name, media_type: mediaType }, reserved);
         }
         catch (error) {
-            turn.parts.arrive({ type: 'marker', marker: 'retry', text: `${name} was not saved: ${causeOf(error)}` }, reserved);
+            const cause = error instanceof HouseRefusal ? (refusalOf(error.text)?.text ?? causeOf(error)) : causeOf(error);
+            turn.parts.arrive({ type: 'marker', marker: 'retry', text: `${name} was not saved: ${cause}` }, reserved);
         }
     }
 }