@agentshouse/kit 0.2.1-c0b2838a220ac → 0.2.1-c0eea939ba749

package/dist/conversations.js

@@ -1,39 +1,88 @@
-import { client, } from '@agentclientprotocol/sdk';
+import { client, RequestError, } from '@agentclientprotocol/sdk';
 import { createHash, randomUUID } from 'node:crypto';
 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 { openBridge } from './bridge.js';
 import { CLIS } from './clis.js';
-import { readerFor } from './events.js';
+import { answeredFailure, readerFor } from './events.js';
 import { placeFiles, uploadBytes } from './files.js';
 import { agentBase } from './home.js';
 import { instructions } from './instructions.js';
 import { Parts } from './parts.js';
+import { refusalOf } from './refusals.js';
 import { killMarked, Scope } from './scope.js';
 import { holdSecretInput } from './secret-input.js';
 import { createHowWeWork } from './skills.js';
 import { transcribe } from './transcription.js';
 import { workFor } from './work.js';
+const SIGNED_OUT = RequestError.authRequired().code;
 const KILLED = 'the conversation was killed';
+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';
+const RETIRED = "this conversation's Agent is retired, so it cannot start";
+const ENDED = {
+    conversation_not_found: GONE,
+    conversation_historical: RETIRED,
+};
+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 NO_SETTINGS = "the Agent's CLI refused the Agent's model, mode or effort";
+class NotStarted extends Error {
+}
+async function step(reason, work) {
+    try {
+        return await work;
+    }
+    catch (error) {
+        throw new NotStarted(typeof reason === 'string' ? reason : reason(error), { cause: error });
+    }
+}
+function unbridged(error) {
+    return (finalRefusal(error) ? ENDED[refusalOf(error.text)?.code ?? ''] : undefined) ?? NO_CONNECTION;
+}
+const EXIT_PLAN_MODE = {
+    parse(value) {
+        if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+            throw new Error('_x.ai/exit_plan_mode needs an object');
+        }
+        return value;
+    },
+};
 export const CONVERSATION_INPUTS = 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) };
+}
+function exitedWith(running, cause) {
+    return running.killed ? { failure: 'killed', cause: KILLED } : { failure: 'exited', cause };
+}
 function answerMessage(request, response) {
     return `The User answered a question you asked earlier.\nQuestion: ${JSON.stringify(request)}\nAnswer: ${JSON.stringify(response)}`;
 }
 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);
+    logged(new Error(`conversation ${conversation.id} did not start: ${cause}`));
+    return causeOf(error);
+}
 function marker(bridge) {
     return `HOUSE_BRIDGE=${bridge.env.HOUSE_BRIDGE}`;
 }
 class Turn {
     id = randomUUID();
     parts;
-    admitted = false;
     questions = 0;
     secrets = 0;
     prompted = false;
@@ -57,6 +106,7 @@ class Conversation {
     subagents = new Map();
     held = [];
     opening = null;
+    prompted = null;
     kills = 0;
     killed = new AbortController();
     interrupts = 0;
@@ -79,9 +129,7 @@ function asksSecret(request) {
 export class Conversations {
     kit;
     conversations = new Map();
-    acks = new Map();
     questions = new Map();
-    carrying = 0;
     reporting = 0;
     watched = false;
     constructor(kit) {
@@ -90,37 +138,26 @@ export class Conversations {
         setInterval(() => this.look(), 2_000);
     }
     input(input) {
-        this.carrying++;
-        const carried = this.acks.get(input.input_id) ??
-            (() => {
-                const conversation = this.conversation(input.conversation_id);
-                if (input.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') {
-                    conversation.interrupts++;
-                    conversation.interrupted.abort();
-                }
-                const handled = conversation.queue.then(() => this.carry(conversation, input));
-                conversation.queue = handled.catch(() => undefined);
-                const work = handled.then(({ ack }) => ack);
-                this.acks.set(input.input_id, work);
-                return work;
-            })();
-        carried
-            .then((body) => this.kit.house.deliver(`/kit/inputs/${input.input_id}/ack`, body))
-            .catch(logged)
-            .finally(() => {
-            this.carrying--;
-            this.kit.changed();
+        void this.kit.inputs.carry(input.input_id, () => {
+            const conversation = this.conversation(input.conversation_id);
+            if (input.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') {
+                conversation.interrupts++;
+                conversation.interrupted.abort();
+            }
+            const handled = conversation.queue.then(() => this.carry(conversation, input));
+            conversation.queue = handled.catch(() => undefined);
+            return handled.then(async ({ ack }) => ({ ack: await ack }));
         });
     }
     idle() {
-        if (this.carrying > 0 || this.reporting > 0)
+        if (this.reporting > 0)
             return false;
         for (const conversation of this.conversations.values()) {
             const turn = conversation.turn;
@@ -200,10 +237,10 @@ export class Conversations {
         if (conversation.running !== null)
             return {};
         try {
-            return { provider_session_id: await this.start(conversation, await this.route(conversation, input.agent_id), null) };
+            return { provider_session_id: await this.start(conversation, await this.route(conversation, input.agent_id), null, true) };
         }
         catch (error) {
-            return { refused: causeOf(error) };
+            return { refused: refusal(conversation, error) };
         }
     }
     async message(conversation, input) {
@@ -220,7 +257,7 @@ export class Conversations {
                 throw new Error(KILLED);
         }
         catch (error) {
-            return { ack: Promise.resolve({ refused: conversation.kills > 0 ? KILLED : causeOf(error) }) };
+            return { ack: Promise.resolve({ refused: refusal(conversation, error) }) };
         }
         return {
             ack: new Promise((settle) => {
@@ -243,13 +280,17 @@ export class Conversations {
     async send(conversation, waiting) {
         const { input } = waiting;
         let ack = {};
+        let started = false;
         const prompt = [];
         try {
             if (conversation.running === null) {
-                const resumed = input.provider_session_id ?? conversation.session;
-                const opened = await this.start(conversation, waiting.route, resumed);
-                if (resumed === null)
-                    ack = { provider_session_id: opened };
+                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;
+            }
+            const session = conversation.running.sessionId;
+            if (started || (input.first === true && session !== input.provider_session_id)) {
+                ack = { provider_session_id: session };
             }
             if (input.first === true) {
                 prompt.push({
@@ -261,11 +302,11 @@ export class Conversations {
                 throw new Error(KILLED);
         }
         catch (error) {
-            if ('provider_session_id' in ack) {
+            if (started) {
                 conversation.session = null;
                 await this.kill(conversation);
             }
-            waiting.settle({ refused: conversation.kills > 0 ? KILLED : causeOf(error) });
+            waiting.settle({ refused: refusal(conversation, error) });
             return;
         }
         this.prompt(conversation, [...prompt, ...waiting.content]);
@@ -343,14 +384,15 @@ export class Conversations {
         }
         return route;
     }
-    async start(conversation, route, sessionId) {
+    async start(conversation, route, sessionId, empty) {
         const reader = readerFor(route.kind);
         reader.session = sessionId;
         const app = client({ name: '@agentshouse/kit' })
             .onRequest('session/request_permission', ({ params, signal }) => this.ask(conversation, 'session/request_permission', params, false, signal))
-            .onRequest('elicitation/create', ({ params, signal }) => this.ask(conversation, 'elicitation/create', params, asksSecret(params), signal));
+            .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 openBridge(this.kit.house, this.kit.copies, conversation.id, conversation.killed.signal);
+        const bridge = await step(unbridged, openBridge(this.kit.house, this.kit.copies, conversation.id, conversation.killed.signal));
         if (conversation.kills > 0) {
             bridge.close();
             throw new Error(KILLED);
@@ -358,27 +400,28 @@ export class Conversations {
         conversation.opening = bridge;
         const work = workFor(route.kind, route.working_directory, () => this.kit.changed());
         const scope = new Scope(marker(bridge), randomUUID(), cli);
+        let adapter = null;
         try {
             await unlessAborted(createHowWeWork(bridge), conversation.killed.signal);
             await CLIS[route.kind].allowHouse(bridge.env.PATH);
-            const adapter = await startAdapter(route.kind, cli, route.working_directory, app, (message) => {
+            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, ...(await work.open(cli)) }, undefined, scope);
+            }, { ...bridge.env, ...streamed }, undefined, scope));
             void adapter.exited.then(() => bridge.close());
             const agent = adapter.connection.agent;
             const cwd = route.working_directory;
             const _meta = CLIS[route.kind].sessionMeta(bridge.env.HOUSE_BRIDGE, conversation.id);
-            const opened = sessionId === null
-                ? await agent.request('session/new', { cwd, mcpServers: [], _meta })
-                : { ...(await agent.request('session/resume', { sessionId, cwd, mcpServers: [], _meta })), sessionId };
+            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 })));
             reader.session = opened.sessionId;
-            if (sessionId === null && CLIS[route.kind].renames) {
+            if (opened.sessionId !== sessionId && CLIS[route.kind].renames) {
                 const prompt = [{ type: 'text', text: `/rename ${conversation.id}` }];
-                await agent.request('session/prompt', { sessionId: opened.sessionId, prompt });
+                await step(NO_SESSION, agent.request('session/prompt', { sessionId: opened.sessionId, prompt }));
             }
             const running = { adapter, bridge, sessionId: opened.sessionId, killed: false, reader, work, scope };
-            const options = await this.launchSettings(running, route, opened.configOptions ?? []);
+            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;
@@ -386,11 +429,11 @@ export class Conversations {
             if (conversation.commands !== null)
                 this.commands(conversation, conversation.commands);
             this.options(conversation, options);
-            void adapter.exited.then((cause) => this.exited(conversation, adapter, cause));
+            void adapter.lost.then((cause) => this.exited(conversation, running, cause));
             return running.sessionId;
         }
         catch (error) {
-            scope.kill();
+            adapter?.retire();
             work.close();
             conversation.leftovers.add(scope);
             bridge.close();
@@ -400,6 +443,18 @@ export class Conversations {
             conversation.opening = null;
         }
     }
+    async resume(conversation, kind, adapter, request, empty) {
+        try {
+            return { ...(await adapter.connection.agent.request('session/resume', request)), sessionId: request.sessionId };
+        }
+        catch (error) {
+            if (!empty || conversation.kills > 0 || !CLIS[kind].unknownSession(error)) {
+                throw new NotStarted(NO_RESUME, { cause: error });
+            }
+            logged(new Error(`conversation ${conversation.id} opens a new session: ${NO_RESUME}: ${causeOf(error)}`));
+            return null;
+        }
+    }
     async launchSettings(running, route, offered) {
         let options = offered;
         const settings = [
@@ -421,13 +476,10 @@ export class Conversations {
         }
         return options;
     }
-    exited(conversation, adapter, cause) {
-        const running = conversation.running;
-        if (running?.adapter !== adapter)
-            return;
+    exited(conversation, running, cause) {
         this.detach(conversation, running);
         if (conversation.turn !== null) {
-            this.end(conversation, conversation.turn, { failed: running.killed ? KILLED : cause });
+            this.end(conversation, conversation.turn, exitedWith(running, cause));
         }
         this.next(conversation);
         this.kit.changed();
@@ -466,7 +518,7 @@ export class Conversations {
         return delivered;
     }
     write(conversation, turn, operation) {
-        if (!turn.admitted || turn.ended || !this.watched)
+        if (turn.ended || !this.watched)
             return;
         this.kit.send({ type: 'turn', conversation_id: conversation.id, turn_id: turn.id, ...operation });
     }
@@ -477,12 +529,7 @@ export class Conversations {
     begin(conversation) {
         const turn = new Turn((operation) => this.write(conversation, turn, operation));
         conversation.open++;
-        void this.deliver(conversation, turn, 'started', {})
-            .then(() => {
-            turn.admitted = true;
-            this.replay(conversation, turn);
-        })
-            .catch(logged);
+        void this.deliver(conversation, turn, 'started', {}).catch(logged);
         conversation.turn = turn;
         if (conversation.context !== null)
             turn.parts.measure(conversation.context);
@@ -491,13 +538,17 @@ export class Conversations {
         this.kit.changed();
         return turn;
     }
-    end(conversation, turn, failed) {
+    end(conversation, turn, failed, notice = null) {
         if (turn.ended)
             return;
+        if (failed !== null)
+            logged(new Error(`conversation ${conversation.id} turn ${turn.id} failed: ${failed.cause}`));
         if (conversation.turn === turn) {
             for (const event of conversation.running?.reader.closeTurn() ?? [])
                 this.apply(conversation, turn, event);
         }
+        if (notice !== null)
+            turn.parts.start({ type: 'marker', marker: 'retry', text: notice });
         turn.ended = true;
         conversation.open--;
         if (conversation.turn === turn)
@@ -505,7 +556,7 @@ export class Conversations {
         const body = Promise.allSettled(turn.uploads).then(() => ({
             parts: turn.parts.saved(),
             context: turn.parts.context,
-            ...failed,
+            ...(failed === null ? {} : { failed: failed.failure }),
         }));
         void this.deliver(conversation, turn, 'ended', body).catch(logged);
         this.next(conversation);
@@ -515,16 +566,25 @@ export class Conversations {
         const running = conversation.running;
         const turn = this.begin(conversation);
         turn.prompted = true;
-        running.adapter.connection.agent.request('session/prompt', { sessionId: running.sessionId, prompt }).then(() => this.end(conversation, turn, null), async (error) => {
+        conversation.prompted = running.sessionId;
+        running.adapter.connection.agent.request('session/prompt', { sessionId: running.sessionId, prompt }).then((answer) => {
+            const notice = answeredFailure(answer);
+            if (notice !== null) {
+                this.end(conversation, turn, { failure: notice.limit ? 'limit' : 'error', cause: notice.title }, notice.title);
+            }
+            else {
+                this.end(conversation, turn, answer.stopReason === 'refusal' ? { failure: 'refused', cause: REFUSED } : null);
+            }
+        }, async (error) => {
             if (running.adapter.connection.signal.aborted) {
-                this.end(conversation, turn, { failed: running.killed ? KILLED : await running.adapter.exited });
+                this.end(conversation, turn, exitedWith(running, await running.adapter.exited));
             }
             else {
                 if (conversation.open === 1 && conversation.running === running) {
-                    running.scope.kill();
+                    running.adapter.retire();
                     this.detach(conversation, running);
                 }
-                this.end(conversation, turn, { failed: causeOf(error) });
+                this.end(conversation, turn, answeredWith(error));
             }
         });
     }