@agentshouse/kit 0.2.1-alpha.2 → 0.2.1-alpha.21

package/dist/conversations.js

@@ -2,14 +2,17 @@ import { client, } from '@agentclientprotocol/sdk';
 import { randomUUID } from 'node:crypto';
 import { mkdir } from 'node:fs/promises';
 import { join } from 'node:path';
+import { unlessAborted } from './abort.js';
 import { killMarked, startAdapter, TURN_ENDED, TURN_STARTED } from './acp.js';
 import { blocksOf, firstChange } from './blocks.js';
 import { openBridge } from './bridge.js';
 import { CLIS } from './clis.js';
 import { placeFiles } from './files.js';
+import { agentBase } from './home.js';
 import { instructions } from './instructions.js';
 import { holdSecretInput } from './secret-input.js';
-const LAUNCH_BASE = '/agents/house';
+import { createHowWeWork } from './skills.js';
+import { transcribe } from './transcription.js';
 const KILLED = 'the conversation was killed';
 function causeOf(error) {
     return error instanceof Error ? error.message : String(error);
@@ -20,30 +23,24 @@ function answerMessage(request, response) {
 function logged(error) {
     process.stderr.write(`kit: ${causeOf(error)}\n`);
 }
-function unlessKilled(work, signal) {
-    return new Promise((resolve, reject) => {
-        const killed = () => reject(signal.reason);
-        signal.addEventListener('abort', killed, { once: true });
-        if (signal.aborted)
-            killed();
-        work.then(resolve, reject).finally(() => signal.removeEventListener('abort', killed));
-    });
-}
 function stop(bridge) {
     killMarked(`HOUSE_BRIDGE=${bridge.env.HOUSE_BRIDGE}`);
 }
 class Turn {
     id = randomUUID();
     text = '';
+    segment = null;
+    admitted = false;
+    notes = [];
     sent = [];
     unsentFrom = null;
     draftSequence = 0;
     planSequence = 0;
+    entries = null;
     questions = 0;
     secrets = 0;
     prompt = null;
     ended = false;
-    ready = Promise.resolve();
 }
 class Conversation {
     id;
@@ -56,6 +53,8 @@ class Conversation {
     opening = null;
     kills = 0;
     killed = new AbortController();
+    interrupts = 0;
+    interrupted = new AbortController();
     open = 0;
     queue = Promise.resolve();
     reports = Promise.resolve();
@@ -91,6 +90,10 @@ export class Conversations {
                     conversation.killed.abort(new Error(KILLED));
                     this.halt(conversation);
                 }
+                if (input.kind === 'interrupt') {
+                    conversation.interrupts++;
+                    conversation.interrupted.abort();
+                }
                 const work = conversation.queue.then(() => this.carry(conversation, input));
                 conversation.queue = work.catch(() => undefined);
                 this.acks.set(input.input_id, work);
@@ -134,8 +137,11 @@ export class Conversations {
             return this.open(conversation, input);
         if (input.kind === 'message')
             return this.message(conversation, input);
-        if (input.kind === 'interrupt')
+        if (input.kind === 'interrupt') {
+            if (--conversation.interrupts === 0)
+                conversation.interrupted = new AbortController();
             await this.interrupt(conversation, String(input.turn_id));
+        }
         if (input.kind === 'kill') {
             await this.kill(conversation);
             if (--conversation.kills === 0)
@@ -167,18 +173,23 @@ export class Conversations {
         const prompt = [];
         try {
             const route = await this.route(conversation, input.agent_id);
-            const paths = await placeFiles(this.kit.house, route.working_directory, input.files, conversation.killed.signal);
+            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 (conversation.running === null) {
                 const opened = await this.start(conversation, route, input.provider_session_id);
                 if (input.provider_session_id === null)
                     ack = { provider_session_id: opened };
             }
             if (input.first === true) {
-                prompt.push({ type: 'text', text: await instructions(conversation.running.bridge, route.base_instructions) });
+                prompt.push({
+                    type: 'text',
+                    text: await instructions(conversation.running.bridge, route.base_instructions, await this.kit.copies.mapping()),
+                });
             }
             prompt.push({ type: 'text', text: String(input.text) });
-            if (paths.length > 0)
-                prompt.push({ type: 'text', text: paths.join('\n') });
+            if (lines.length > 0)
+                prompt.push({ type: 'text', text: lines.join('\n') });
             if (conversation.kills > 0)
                 throw new Error(KILLED);
         }
@@ -190,6 +201,25 @@ export class Conversations {
         this.prompt(conversation, prompt);
         return ack;
     }
+    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 !== '')
+                    lines.push(`Transcript: ${text}`);
+            }
+            catch (error) {
+                if (conversation.kills > 0)
+                    throw error;
+                logged(new Error(`${files[index].name} was not transcribed: ${causeOf(error)}`));
+            }
+        }
+        return lines;
+    }
     async interrupt(conversation, turnId) {
         if (conversation.running === null || conversation.turn?.id !== turnId)
             return;
@@ -228,13 +258,13 @@ export class Conversations {
     }
     async route(conversation, agentId) {
         const signal = conversation.killed.signal;
-        await unlessKilled(this.kit.agents.read(), signal);
+        await unlessAborted(this.kit.agents.read(), signal);
         if (this.kit.agents.route(agentId) === undefined)
-            await unlessKilled(this.kit.agents.refresh(), signal);
+            await unlessAborted(this.kit.agents.refresh(), signal);
         const route = this.kit.agents.route(agentId);
         if (route === undefined)
             throw new Error(`this Environment hosts no Agent ${agentId}`);
-        if (route.working_directory === join(LAUNCH_BASE, route.agent_id)) {
+        if (route.working_directory === join(agentBase(), route.agent_id)) {
             await mkdir(route.working_directory, { recursive: true });
         }
         return route;
@@ -246,15 +276,16 @@ export class Conversations {
             .onNotification(TURN_ENDED, (params) => params, () => this.ended(conversation))
             .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));
-        await unlessKilled(this.kit.agents.installed(), conversation.killed.signal);
-        const bridge = await openBridge(this.kit.house, conversation.id, conversation.killed.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);
         if (conversation.kills > 0) {
             bridge.close();
             throw new Error(KILLED);
         }
         conversation.opening = bridge;
         try {
-            const adapter = await startAdapter(route.kind, route.working_directory, app, (job) => this.job(conversation, job), { ...process.env, ...bridge.env });
+            await unlessAborted(createHowWeWork(bridge), conversation.killed.signal);
+            const adapter = await startAdapter(route.kind, cli, route.working_directory, app, (job) => this.job(conversation, job), bridge.env);
             void adapter.exited.then(() => bridge.close());
             const agent = adapter.connection.agent;
             const cwd = route.working_directory;
@@ -267,6 +298,7 @@ export class Conversations {
                 sessionId: opened.sessionId,
                 killed: false,
                 queues: CLIS[route.kind].queues,
+                phase: CLIS[route.kind].phase,
             };
             const options = await this.launchSettings(running, route, opened.configOptions ?? []);
             conversation.running = running;
@@ -348,15 +380,39 @@ export class Conversations {
     report(conversation) {
         const turn = new Turn();
         conversation.open++;
-        turn.ready = this.deliver(conversation, turn, 'started', {}).then(() => undefined, logged);
+        void this.deliver(conversation, turn, 'started', {})
+            .then(() => this.admitted(conversation, turn))
+            .catch(logged);
         return turn;
     }
+    admitted(conversation, turn) {
+        turn.admitted = true;
+        for (const note of turn.notes.splice(0))
+            this.kit.send(note);
+        if (turn.text !== '') {
+            turn.unsentFrom = 0;
+            this.draft(conversation, turn);
+        }
+        if (turn.entries !== null)
+            this.plan(conversation, turn);
+    }
     begin(conversation) {
         const turn = this.report(conversation);
         conversation.turn = turn;
         this.kit.changed();
         return turn;
     }
+    finish(conversation, turn) {
+        if (turn.ended)
+            return;
+        const segment = turn.segment;
+        turn.segment = null;
+        if (segment?.phase === 'note')
+            this.note(conversation, turn, segment.text);
+        else if (segment !== null)
+            this.answer(conversation, turn, segment.text);
+        this.end(conversation, turn, { text: turn.text });
+    }
     end(conversation, turn, outcome) {
         if (turn.ended)
             return;
@@ -414,7 +470,7 @@ export class Conversations {
                 this.end(conversation, turn, { failed });
         }
         else if (turn.prompt === sent) {
-            this.end(conversation, turn, { text: turn.text });
+            this.finish(conversation, turn);
         }
     }
     started(conversation) {
@@ -431,7 +487,7 @@ export class Conversations {
         if (turn === null)
             return;
         if (turn.prompt === null) {
-            this.end(conversation, turn, { text: turn.text });
+            this.finish(conversation, turn);
         }
         else {
             conversation.turn = null;
@@ -485,17 +541,21 @@ export class Conversations {
     update(conversation, notification) {
         const update = notification.update;
         if (update.sessionUpdate === 'agent_message_chunk' && update.content.type === 'text') {
-            const turn = this.started(conversation);
-            turn.text += update.content.text;
-            const text = turn.text;
-            void turn.ready.then(() => this.draft(conversation, turn, text));
+            this.chunk(conversation, this.started(conversation), update, update.content.text);
         }
         else if (update.sessionUpdate === 'plan') {
             const turn = this.started(conversation);
-            void turn.ready.then(() => this.plan(conversation, turn, update.entries));
+            this.close(conversation, turn);
+            turn.entries = update.entries;
+            this.plan(conversation, turn);
+        }
+        else if (update.sessionUpdate === 'tool_call') {
+            this.close(conversation, this.started(conversation));
         }
-        else if (update.sessionUpdate === 'agent_thought_chunk' || update.sessionUpdate === 'tool_call') {
-            this.started(conversation);
+        else if (update.sessionUpdate === 'agent_thought_chunk') {
+            const turn = this.started(conversation);
+            if (turn.segment?.messageId !== (update.messageId ?? null))
+                this.close(conversation, turn);
         }
         else if (update.sessionUpdate === 'available_commands_update') {
             this.commands(conversation, update.availableCommands);
@@ -511,8 +571,40 @@ export class Conversations {
             conversation.jobs.delete(job.id);
         this.kit.changed();
     }
-    draft(conversation, turn, text) {
-        const blocks = blocksOf(text);
+    chunk(conversation, turn, chunk, text) {
+        const phase = conversation.running?.phase(chunk) ?? null;
+        const messageId = chunk.messageId ?? null;
+        if (turn.segment?.messageId !== messageId || turn.segment.phase !== phase)
+            this.close(conversation, turn);
+        if (phase === 'answer') {
+            this.answer(conversation, turn, text);
+            return;
+        }
+        turn.segment ??= { messageId, phase, text: '' };
+        turn.segment.text += text;
+    }
+    close(conversation, turn) {
+        const segment = turn.segment;
+        if (segment === null)
+            return;
+        turn.segment = null;
+        this.note(conversation, turn, segment.text);
+    }
+    note(conversation, turn, text) {
+        if (text.trim() === '')
+            return;
+        const note = { type: 'working-note', conversation_id: conversation.id, note_id: randomUUID(), text };
+        if (turn.admitted)
+            this.kit.send(note);
+        else
+            turn.notes.push(note);
+    }
+    answer(conversation, turn, text) {
+        turn.text += text;
+        this.draft(conversation, turn);
+    }
+    draft(conversation, turn) {
+        const blocks = blocksOf(turn.text);
         const from = Math.min(firstChange(turn.sent, blocks), turn.unsentFrom ?? Infinity);
         const sent = this.kit.send({
             type: 'draft',
@@ -531,14 +623,14 @@ export class Conversations {
             turn.unsentFrom = from;
         }
     }
-    plan(conversation, turn, entries) {
+    plan(conversation, turn) {
         const sent = this.kit.send({
             type: 'plan',
             conversation_id: conversation.id,
             turn_id: turn.id,
             sequence: turn.planSequence + 1,
             from: 0,
-            steps: entries.map((entry) => ({ label: entry.content, priority: entry.priority, status: entry.status })),
+            steps: turn.entries.map((entry) => ({ label: entry.content, priority: entry.priority, status: entry.status })),
         });
         if (sent)
             turn.planSequence++;