genaicode 2.14.0 → 2.15.0

package/dist/app-agent/app-agent.js

@@ -0,0 +1,678 @@
+import { randomBytes } from 'node:crypto';
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { setTimeout as delay } from 'node:timers/promises';
+import { detectAgents } from '../agents/discovery.js';
+import { MCP_NAME } from '../agents/prepare.js';
+import { createAgentSession } from '../agents/session.js';
+import { commitTree, snapshotTree, treeChanges } from './git.js';
+import { safeJson } from './json.js';
+import { defaultAppAgents } from './policy.js';
+import { APP_NOTE, PROMPT_MARKER, userText, } from './state.js';
+/**
+ * A tool the app gives its agent. Read tools run when the agent calls them. Write tools
+ * (`write: true`) only create an action: the user approves or rejects it in the app, and the
+ * agent hears the outcome as its next message.
+ */
+const APPROVAL_SUMMARY = 'approval_summary';
+export class AppAgentError extends Error {
+    status;
+    constructor(message, status) {
+        super(message);
+        this.status = status;
+    }
+}
+const MAX_ACTIONS = 50;
+const MAX_LINKS = 6;
+const MAX_HISTORY = 100;
+const CARRY_MAX = 12_000;
+const STOP_WAIT_MS = 10_000;
+const COPILOT_KINDS = ['read', 'write', 'shell', 'url', 'memory'];
+/**
+ * A coding agent inside a local app: the user chats with an agent CLI from their machine
+ * (Claude Code, Codex, Copilot...), the agent uses the app through tools the app serves over
+ * MCP, writes wait for the user's approval, and in `dev` mode the agent also changes the
+ * app's code and proposes a commit of exactly the reviewed tree.
+ *
+ * This is the state and logic only; `createAppAgentHandler` serves it over HTTP.
+ */
+export function createAppAgent(options) {
+    const names = new Set(['app_view', 'app_links', 'app_open', 'propose_commit']);
+    for (const tool of options.tools ?? []) {
+        if (names.has(tool.name))
+            throw new Error(`tool name "${tool.name}" is taken`);
+        names.add(tool.name);
+        const properties = (tool.inputSchema?.properties ?? {});
+        if (tool.write && APPROVAL_SUMMARY in properties) {
+            throw new Error(`write tool "${tool.name}" cannot take an argument named ${APPROVAL_SUMMARY}`);
+        }
+    }
+    const now = options.now ?? Date.now;
+    const env = options.env ?? process.env;
+    const serverName = options.serverName ?? 'app';
+    // Checked here, not on the first turn: every driver refuses other names.
+    if (!MCP_NAME.test(serverName))
+        throw new Error(`serverName must match ${MCP_NAME}: ${JSON.stringify(serverName)}`);
+    // Copilot reads these bare names as permission kinds, so its rules would not name the server.
+    if (COPILOT_KINDS.includes(serverName))
+        throw new Error(`serverName "${serverName}" is a Copilot permission kind`);
+    // A dropped session's process may still be winding down: its late calls must not reach the app.
+    const newToken = () => randomBytes(24).toString('base64url');
+    let mcpToken = newToken();
+    const modes = options.dev ? ['use', 'dev'] : ['use'];
+    const agentsFor = (target) => options.agents?.(target) ?? defaultAppAgents(target, options.dev?.commands ?? []);
+    // PATH lookups once per mode, not on every streamed update.
+    const found = new Map();
+    const installed = (target) => {
+        let list = found.get(target);
+        if (!list) {
+            list = detectAgents(agentsFor(target), env).map(({ agent, path: where }) => ({
+                name: agent.name,
+                installed: where !== null,
+            }));
+            found.set(target, list);
+        }
+        return list;
+    };
+    let mode = 'use';
+    const startList = installed(mode);
+    let agentName = options.agent ?? startList.find((choice) => choice.installed)?.name ?? startList[0]?.name ?? 'claude';
+    if (!startList.some((choice) => choice.name === agentName)) {
+        throw new AppAgentError(`Unknown agent "${agentName}".`, 400);
+    }
+    let session = null;
+    let unsubscribeSession = null;
+    let briefed = false;
+    let useCwd = null;
+    let actions = [];
+    let nextAction = 1;
+    let view = null;
+    let links = [];
+    let navigation = null;
+    let history = [];
+    let nextArchivedId = -1;
+    let carryOver = '';
+    // The user's prompts sent while an action runs: they follow its outcome, never overtake it.
+    let held = [];
+    // The turn each commit was proposed in: approving one stops that turn, never a newer prompt.
+    // Turn ids restart in a new session (after a switch), so the session is part of the key.
+    const proposedIn = new Map();
+    const runningTurn = () => (session?.get().status === 'running' ? session.get().turns.at(-1)?.id : undefined);
+    // The session's own queue, kept aside while a commit stops its turn; a user stop drops it too.
+    let saved = [];
+    let closed = false;
+    let traced = new Set();
+    // Logging only observes: a failing sink must not change what happens (an action's status).
+    const trace = (record) => {
+        try {
+            // An async sink's rejection is dropped too, never left unhandled.
+            const result = options.trace?.(record);
+            if (result instanceof Promise)
+                result.catch(() => { });
+        }
+        catch {
+            // dropped
+        }
+    };
+    const listeners = new Set();
+    const get = () => ({
+        name: options.name,
+        mode,
+        modes,
+        agent: agentName,
+        agents: installed(mode),
+        session: session && (saved.length || held.length)
+            ? { ...session.get(), queued: [...saved, ...session.get().queued, ...held] }
+            : (session?.get() ?? null),
+        history,
+        actions,
+        links,
+        view,
+        navigation,
+    });
+    const changed = () => {
+        traceTurns();
+        const state = get();
+        for (const listener of [...listeners]) {
+            try {
+                listener(state);
+            }
+            catch {
+                // Keep other subscribers going.
+            }
+        }
+    };
+    const traceTurns = () => {
+        if (!options.trace)
+            return;
+        for (const turn of session?.get().turns ?? []) {
+            if (!turn.result || traced.has(turn.id))
+                continue;
+            const record = {
+                kind: 'turn',
+                agent: turn.agent,
+                mode,
+                turn: turn.id,
+                status: turn.result.status,
+                ok: turn.result.ok,
+                ...(turn.result.error ? { error: turn.result.error } : {}),
+                ms: (turn.endedAt ?? now()) - turn.startedAt,
+                ...(turn.costUsd !== undefined ? { costUsd: turn.costUsd } : {}),
+                entries: turn.entries.map((entry) => entry.kind === 'tool'
+                    ? {
+                        ...entry,
+                        input: clip(safeJson(entry.input), 1_000),
+                        output: clip(entry.output ?? '', 2_000),
+                    }
+                    : entry.kind === 'text'
+                        ? { ...entry, text: clip(entry.text, 4_000) }
+                        : entry),
+            };
+            traced.add(turn.id);
+            trace(record);
+        }
+    };
+    const cwdFor = (target) => {
+        if (target === 'dev')
+            return options.dev.cwd;
+        // No files to touch in use mode: an empty directory keeps the agent on the app's tools.
+        if (!useCwd) {
+            useCwd = mkdtempSync(path.join(tmpdir(), 'genaicode-app-agent-'));
+            // Copilot reads hooks from the user's config too; its repository settings switch them all off.
+            mkdirSync(path.join(useCwd, '.github', 'copilot'), { recursive: true });
+            writeFileSync(path.join(useCwd, '.github', 'copilot', 'settings.json'), '{ "disableAllHooks": true }\n');
+        }
+        return useCwd;
+    };
+    const ensureSession = () => {
+        if (session)
+            return session;
+        const agent = agentsFor(mode).find((candidate) => candidate.name === agentName);
+        if (!agent)
+            throw new AppAgentError(`Agent "${agentName}" is not offered in ${mode} mode.`, 400);
+        const url = typeof options.mcpUrl === 'function' ? options.mcpUrl() : options.mcpUrl;
+        session = createAgentSession({
+            agent,
+            cwd: cwdFor(mode),
+            task: {
+                env,
+                mcpServers: [{ name: serverName, url, headers: { authorization: `Bearer ${mcpToken}` } }],
+            },
+        });
+        unsubscribeSession = session.subscribe(changed);
+        briefed = false;
+        traced = new Set();
+        trace({ kind: 'session', agent: agentName, mode });
+        return session;
+    };
+    // The turns so far stay in the conversation; negative ids keep their chips attached.
+    const archiveSession = () => {
+        const turns = session?.get().turns ?? [];
+        if (turns.length === 0)
+            return;
+        const ids = new Map(turns.map((turn) => [turn.id, nextArchivedId--]));
+        history = [...history, ...turns.map((turn) => ({ ...turn, id: ids.get(turn.id) }))].slice(-MAX_HISTORY);
+        links = links.flatMap((link) => {
+            if (link.turnId < 0)
+                return [link];
+            const id = ids.get(link.turnId);
+            return id === undefined ? [] : [{ ...link, turnId: id }];
+        });
+        carryOver = clip(`${carryOver}\n\n${transcript(turns)}`.trim(), CARRY_MAX, true);
+    };
+    // Notes the old session still held (the user stopped its turn) go to the next agent.
+    const archiveNotes = () => {
+        for (const note of session?.get().notes ?? []) {
+            carryOver = clip(`${carryOver}\n\n${userText(note)}`.trim(), CARRY_MAX, true);
+        }
+    };
+    const dropSession = () => {
+        traceTurns();
+        links = links.filter((link) => link.turnId < 0);
+        unsubscribeSession?.();
+        session?.close();
+        session = null;
+        unsubscribeSession = null;
+        briefed = false;
+        mcpToken = newToken();
+    };
+    const briefing = () => {
+        const tool = (name) => `\`${name}\``;
+        const lines = [
+            `You are the assistant inside ${options.name}, a local app on the user's machine.`,
+            `Use the \`${serverName}\` MCP tools to read from and act in the app.`,
+            'Tools that make changes do not run at once: the user approves or rejects each one in the app,',
+            'and you get a message with the outcome. Never say a change happened before that message.',
+            'Answer in the language the user writes in. Be brief and lead with the answer.',
+        ];
+        if (options.pages) {
+            lines.push(`Prompts start with the page the user has open; ${tool('app_view')} reads it again.`, `When a page of the app shows what you mean, offer it with ${tool('app_links')} chips.`, 'Chips appear under your reply on their own; do not point at them.', `Call ${tool('app_open')} only when the user asks you to take them somewhere.`);
+        }
+        if (mode === 'dev' && options.dev) {
+            const commands = options.dev.commands ?? [];
+            lines.push('', `Dev mode: your cwd is ${options.dev.cwd}; you may change the app's own code there.`, ...(commands.length ? [`You may run: ${commands.join(', ')}.`] : []), 'Do not commit or push. When the change is ready, call `propose_commit` with a commit message;', 'the user reviews the diff and approves it.', ...(options.dev.instructions ? [options.dev.instructions] : []));
+        }
+        const extra = typeof options.instructions === 'function' ? options.instructions(mode) : options.instructions;
+        if (extra)
+            lines.push('', extra);
+        return lines.join('\n');
+    };
+    // App notes go ahead of queued prompts and survive a stop: an action's outcome is the agent's
+    // next message.
+    const deliver = (text, withView, note = false, queue = false) => {
+        if (closed)
+            return;
+        const target = ensureSession();
+        const seen = withView && view ? `[The user has ${view} open]` : '';
+        if (!briefed) {
+            briefed = true;
+            const earlier = carryOver ? `\n\nEarlier in this conversation, with another agent or mode:\n${carryOver}` : '';
+            target.send(`${briefing()}${earlier}${seen ? `\n\n${seen}` : ''}${PROMPT_MARKER}${text}`, { note, queue });
+        }
+        else {
+            target.send(seen ? `${seen}${PROMPT_MARKER}${text}` : text, { note, queue });
+        }
+    };
+    // App notes reach an agent that is already talking; they never start a conversation.
+    const tell = (text) => {
+        if (!session) {
+            // The conversation moved to another agent or mode: the next one hears it in its briefing.
+            if (carryOver)
+                carryOver = clip(`${carryOver}\n\n${APP_NOTE}${text}`, CARRY_MAX, true);
+            return;
+        }
+        trace({ kind: 'note', text: clip(text, 2_000) });
+        deliver(`${APP_NOTE}${text}`, false, true);
+    };
+    const updateAction = (id, patch) => {
+        actions = actions.map((action) => (action.id === id ? { ...action, ...patch } : action));
+        changed();
+    };
+    const propose = (action) => {
+        const open = actions.filter((candidate) => candidate.status === 'pending' || candidate.status === 'running');
+        if (open.length >= MAX_ACTIONS) {
+            throw new Error(`${open.length} actions already wait for the user; wait for their decisions first`);
+        }
+        const created = { ...action, id: String(nextAction++), status: 'pending', createdAt: now() };
+        actions = [...actions, created];
+        // Only settled actions make room: a pending one still waits for the user.
+        while (actions.length > MAX_ACTIONS) {
+            const settled = actions.findIndex((candidate) => candidate.status !== 'pending' && candidate.status !== 'running');
+            if (settled < 0)
+                break;
+            actions = actions.filter((_, index) => index !== settled);
+        }
+        changed();
+        return created;
+    };
+    const knownPage = (value) => {
+        const target = String(value ?? '');
+        const pages = options.pages?.() ?? [];
+        if (!pages.includes(target))
+            throw new Error(`unknown page "${target}"; known: ${pages.join(', ')}`);
+        return target;
+    };
+    const waiting = (action) => `Waiting for the user as action #${action.id}. You will get a message with the outcome.`;
+    const appTools = () => (options.tools ?? []).map((tool) => {
+        const schema = tool.inputSchema ?? { type: 'object', properties: {} };
+        if (!tool.write) {
+            return {
+                name: tool.name,
+                description: tool.description,
+                inputSchema: schema,
+                call: async (args) => {
+                    tool.validate?.(args);
+                    return await tool.run(args);
+                },
+            };
+        }
+        const properties = (schema.properties ?? {});
+        const required = Array.isArray(schema.required) ? schema.required : [];
+        return {
+            name: tool.name,
+            description: `${tool.description} Runs only after the user approves it.`,
+            inputSchema: {
+                ...schema,
+                type: 'object',
+                properties: {
+                    ...properties,
+                    [APPROVAL_SUMMARY]: { type: 'string', description: 'One line the user reads before approving' },
+                },
+                required: [...required, APPROVAL_SUMMARY],
+            },
+            call: async (args) => {
+                const { [APPROVAL_SUMMARY]: summary, ...rest } = args;
+                tool.validate?.(rest);
+                const action = propose({
+                    kind: 'tool',
+                    summary: String(summary ?? '').trim() || tool.name,
+                    tool: { name: tool.name, args: rest },
+                });
+                return waiting(action);
+            },
+        };
+    });
+    const pageTools = () => [
+        {
+            name: 'app_view',
+            description: 'The page the user has open in the app now, and the pages they can open.',
+            inputSchema: { type: 'object', properties: {} },
+            call: async () => `Open: ${view ?? 'unknown'}\nPages: ${(options.pages?.() ?? []).join(', ')}`,
+        },
+        {
+            name: 'app_links',
+            description: 'Offer the user clickable chips under your answer, each opening a page of the app.',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    links: {
+                        type: 'array',
+                        maxItems: MAX_LINKS,
+                        items: {
+                            type: 'object',
+                            properties: { label: { type: 'string' }, path: { type: 'string' } },
+                            required: ['label', 'path'],
+                        },
+                    },
+                },
+                required: ['links'],
+            },
+            call: async (args) => {
+                const turnId = session?.get().turns.at(-1)?.id;
+                if (!turnId)
+                    throw new Error('no turn to attach links to');
+                const offered = (Array.isArray(args.links) ? args.links : []).slice(0, MAX_LINKS).map((link) => {
+                    const { label, path: target } = (link ?? {});
+                    const page = knownPage(target);
+                    return { turnId, label: String(label ?? '').slice(0, 60) || page, path: page };
+                });
+                links = [...links, ...offered].slice(-30);
+                changed();
+                return `Showing ${offered.length} chip(s).`;
+            },
+        },
+        {
+            name: 'app_open',
+            description: 'Open a page of the app for the user. Use only when they ask to go there.',
+            inputSchema: { type: 'object', properties: { path: { type: 'string' } }, required: ['path'] },
+            call: async (args) => {
+                const target = knownPage(args.path);
+                // Time-based: a restarted or another backend never reuses an id the page already followed.
+                navigation = { id: Math.max(now(), (navigation?.id ?? 0) + 1), path: target };
+                changed();
+                return `Opened ${target}.`;
+            },
+        },
+    ];
+    const devTools = () => [
+        {
+            name: 'propose_commit',
+            description: 'Ask the user to commit all current changes in the repository with this message.',
+            inputSchema: {
+                type: 'object',
+                properties: { message: { type: 'string', description: 'Commit message: subject line, blank line, body' } },
+                required: ['message'],
+            },
+            call: async (args) => {
+                const message = String(args.message ?? '').trim();
+                if (!message)
+                    throw new Error('message is required');
+                const token = mcpToken;
+                const snapshot = await snapshotTree(repo());
+                // A reset or agent switch meanwhile: this call belongs to a session that is gone.
+                if (token !== mcpToken)
+                    throw new Error('This session has ended.');
+                const action = propose({ kind: 'commit', summary: message.split('\n')[0], commit: { message, ...snapshot } });
+                proposedIn.set(action.id, { session, turn: runningTurn() });
+                return waiting(action);
+            },
+        },
+    ];
+    const repo = () => options.dev?.repo ?? options.dev.cwd;
+    const execute = async (action) => {
+        updateAction(action.id, { status: 'running' });
+        try {
+            if (action.kind === 'commit') {
+                // No edits may land between the check and the commit. Stopping drops the queue: keep it.
+                const stopped = session;
+                saved = [...saved, ...(stopped?.get().queued ?? [])];
+                stopped?.stop();
+                try {
+                    // Let the stopped run wind down: none of its edits may land after the check.
+                    const ended = !stopped ||
+                        (await Promise.race([
+                            stopped.idle().then(() => true),
+                            delay(options.stopTimeoutMs ?? STOP_WAIT_MS, false, { ref: false }),
+                        ]));
+                    // A throw is this action's outcome too: it must reach the agent before the queued prompts.
+                    // The user can only approve what they could read: a clipped diff never lands, whichever client approved it.
+                    const land = async () => !ended
+                        ? {
+                            ok: false,
+                            output: 'The agent did not stop in time, so nothing was committed; approve again once it is idle.',
+                        }
+                        : (await treeChanges(repo(), action.commit)).truncated
+                            ? {
+                                ok: false,
+                                output: 'The diff is too large to review in full; split the change into smaller commits.',
+                            }
+                            : commitTree(repo(), action.commit, action.commit.message);
+                    const outcome = await land().catch((error) => ({ ok: false, output: error.message }));
+                    // A note sent while the stopped run still winds down would wait for the user's next
+                    // prompt; send it once the session is idle, so it starts its own turn. Until then the
+                    // action still runs, so a prompt sent meanwhile is held behind its outcome.
+                    if (stopped && session === stopped)
+                        await stopped.idle();
+                    updateAction(action.id, { status: outcome.ok ? 'done' : 'failed', result: outcome.output });
+                    tell(`Commit #${action.id} ${outcome.ok ? 'succeeded' : 'failed'}:\n${outcome.output}`);
+                }
+                finally {
+                    // The last of several commits approved together gives the queue back.
+                    const others = actions.some((other) => other.id !== action.id && other.kind === 'commit' && other.status === 'running');
+                    if (!others) {
+                        const restore = saved;
+                        saved = [];
+                        if (session === stopped)
+                            for (const prompt of restore)
+                                session?.send(prompt, { queue: true });
+                    }
+                }
+            }
+            else {
+                const tool = options.tools?.find((candidate) => candidate.name === action.tool.name);
+                if (!tool)
+                    throw new Error(`tool ${action.tool.name} is gone`);
+                const output = await tool.run(action.tool.args);
+                updateAction(action.id, { status: 'done', result: output });
+                tell(`The user approved action #${action.id} (${action.summary}). Result:\n${output}`);
+            }
+        }
+        catch (error) {
+            updateAction(action.id, { status: 'failed', result: error.message });
+            tell(`Action #${action.id} failed: ${error.message}`);
+        }
+        finally {
+            if (!actions.some((candidate) => candidate.status === 'running')) {
+                const release = held;
+                held = [];
+                // Behind every outcome note, never steered into one.
+                for (const prompt of release)
+                    deliver(prompt, true, false, true);
+            }
+        }
+    };
+    return {
+        get mcpToken() {
+            return mcpToken;
+        },
+        serverName,
+        get,
+        subscribe(listener) {
+            listeners.add(listener);
+            return () => listeners.delete(listener);
+        },
+        send(text) {
+            const trimmed = text.trim();
+            if (!trimmed)
+                throw new AppAgentError('empty message', 400);
+            trace({ kind: 'prompt', agent: agentName, mode, view, text: clip(trimmed, 4_000) });
+            if (actions.some((action) => action.status === 'running')) {
+                held = [...held, trimmed];
+                changed();
+                return;
+            }
+            // An outcome note still waiting (a rejection while the proposing turn runs) goes first.
+            // A pending commit stops its turn when approved: a prompt steered into that turn could be lost.
+            const commitPending = actions.some((action) => action.kind === 'commit' && action.status === 'pending');
+            deliver(trimmed, true, false, commitPending || !!session?.get().notes?.length);
+        },
+        stop() {
+            if (held.length || saved.length) {
+                held = [];
+                saved = [];
+                changed();
+            }
+            session?.stop();
+        },
+        reset() {
+            if (actions.some((action) => action.status === 'running'))
+                throw new AppAgentError('an action is running', 409);
+            dropSession();
+            history = [];
+            links = [];
+            carryOver = '';
+            // A fresh conversation cannot hear their outcome: nothing waits for the user any more.
+            actions = actions.map((action) => action.status === 'pending' ? { ...action, status: 'rejected', result: 'Dropped by starting over.' } : action);
+            changed();
+        },
+        configure(change) {
+            const nextMode = change.mode ?? mode;
+            if (!modes.includes(nextMode))
+                throw new AppAgentError(`unknown mode "${nextMode}"`, 400);
+            const offered = installed(nextMode);
+            // A mode-only switch keeps the agent when the target mode offers it, else picks one there.
+            const nextAgent = change.agent ??
+                (offered.some((choice) => choice.name === agentName)
+                    ? agentName
+                    : (offered.find((choice) => choice.installed)?.name ?? offered[0]?.name ?? agentName));
+            if (!agentsFor(nextMode).some((agent) => agent.name === nextAgent)) {
+                throw new AppAgentError(`unknown agent "${nextAgent}"`, 400);
+            }
+            if (session?.get().status === 'running')
+                throw new AppAgentError('the agent is busy', 409);
+            if (nextMode === mode && nextAgent === agentName)
+                return;
+            // A running action reports to this conversation (and a commit gives back its queue).
+            if (actions.some((action) => action.status === 'running'))
+                throw new AppAgentError('an action is running', 409);
+            archiveSession();
+            archiveNotes();
+            mode = nextMode;
+            agentName = nextAgent;
+            dropSession();
+            changed();
+        },
+        setView(next) {
+            if (next === view)
+                return;
+            view = next;
+            changed();
+        },
+        decide(id, decision) {
+            // Nothing runs once the app closed the agent, whoever still holds it.
+            if (closed)
+                throw new AppAgentError('the agent is closed', 409);
+            const action = actions.find((candidate) => candidate.id === id);
+            if (!action)
+                throw new AppAgentError('no such action', 404);
+            if (action.status !== 'pending')
+                throw new AppAgentError(`action is ${action.status}`, 409);
+            if (decision === 'approve' && action.kind === 'commit') {
+                const active = runningTurn();
+                const proposed = proposedIn.get(id);
+                if (active !== undefined && (proposed?.session !== session || active !== proposed.turn)) {
+                    throw new AppAgentError('the agent is working on a newer prompt; approve the commit once it finishes', 409);
+                }
+            }
+            trace({ kind: 'decision', action: id, summary: action.summary, decision });
+            proposedIn.delete(id);
+            if (decision === 'reject') {
+                updateAction(id, { status: 'rejected' });
+                tell(`The user rejected action #${id} (${action.summary}).`);
+            }
+            else {
+                void execute(action);
+            }
+        },
+        approve(id, decision) {
+            if (!session?.approve(id, decision))
+                throw new AppAgentError('no such approval request', 404);
+        },
+        async changes(id) {
+            const action = actions.find((candidate) => candidate.id === id);
+            if (!action?.commit)
+                throw new AppAgentError('no such commit action', 404);
+            return treeChanges(repo(), action.commit);
+        },
+        mcpTools() {
+            const tools = [...appTools(), ...(options.pages ? pageTools() : []), ...(mode === 'dev' ? devTools() : [])];
+            if (!options.trace)
+                return tools;
+            return tools.map((tool) => ({
+                ...tool,
+                call: async (args) => {
+                    const started = now();
+                    try {
+                        const result = await tool.call(args);
+                        trace({ kind: 'mcp', tool: tool.name, args, ok: true, ms: now() - started, result: clip(result, 2_000) });
+                        return result;
+                    }
+                    catch (error) {
+                        const message = error.message;
+                        trace({ kind: 'mcp', tool: tool.name, args, ok: false, ms: now() - started, error: message });
+                        throw error;
+                    }
+                },
+            }));
+        },
+        close() {
+            closed = true;
+            held = [];
+            saved = [];
+            listeners.clear();
+            dropSession();
+            if (useCwd)
+                rmSync(useCwd, { recursive: true, force: true });
+            useCwd = null;
+        },
+    };
+}
+function clip(text, max, keepEnd = false) {
+    if (text.length <= max)
+        return text;
+    return keepEnd ? `… (earlier part dropped)\n${text.slice(-max)}` : `${text.slice(0, max)}… (clipped)`;
+}
+// What the user asked and what came back, without the tool calls.
+function transcript(turns) {
+    return turns
+        .map((turn) => {
+        // Input steered into the turn is the user's too, in its place among the answers.
+        const lines = [`User: ${userText(turn.prompt).trim()}`];
+        let last;
+        for (const entry of turn.entries) {
+            if (entry.kind === 'text')
+                last = entry.text;
+            if (entry.kind !== 'input')
+                continue;
+            if (last !== undefined)
+                lines.push(`${turn.agent}: ${last.trim()}`);
+            last = undefined;
+            lines.push(`User: ${userText(entry.text).trim()}`);
+        }
+        lines.push(`${turn.agent}: ${last?.trim() ?? '(no answer)'}`);
+        return lines.join('\n');
+    })
+        .join('\n\n');
+}
+//# sourceMappingURL=app-agent.js.map