@nocobase/app-plugin-agents 0.0.0-stage → 0.1.0-beta.2

package/dist/server/core/conversations/conversation.service.js

@@ -0,0 +1,1356 @@
+import { onlineEntriesOrDefault, sameEntry, } from '../../../shared/agents.js';
+import { CONVERSATION_HISTORY_IN_PROMPT, CONVERSATION_PAGE_DEFAULT, CONVERSATION_PAGE_MAX, CONVERSATION_SOURCE_PATTERN, CONVERSATION_SUBJECT, CONVERSATION_TITLE_AGENT_MAX, CONVERSATION_TITLE_AUTO_CHARS, CONVERSATION_TITLE_MAX, MESSAGE_CONTENT_MAX, MESSAGE_PAGE_DEFAULT, MESSAGE_PAGE_MAX, chatModelChoices, } from '../../../shared/conversations.js';
+import { CONSULT_MAX_DEPTH } from '../../../shared/runs.js';
+import { ACCESS_NAMESPACE } from '../../../shared/access.js';
+import { sampleValue } from '../../../shared/briefs.js';
+import { forbidden, invalid, notFound, ProtocolError, } from '../../kernel/errors.js';
+import { asJson } from '../../kernel/values.js';
+import { findAgent } from '../agents/index.js';
+import { eventsAfter, hasSession, lastSummary, onlineEntryOf, openRunsOnEach, } from '../runs/index.js';
+import { findRunRecord, toRun } from '../runs/run.store.js';
+import { readAttachmentIds, storedAttachments, } from './attachments.js';
+import { availabilityOf, wakeable } from './availability.js';
+import { appendMessage, conversationsRepo, findConversation, findDraft, metadataOf, rewriteMessage, lockConversation, messagesRepo, toMessage, updateMessageRun, } from './conversation.store.js';
+import { hasContent, renderPageContext, } from './page-context.js';
+import { attachmentLines, conversationContext, conversationKey, conversationSystemLayer, conversationTask, conversationTurn, conversationUrl, } from './prompt.js';
+import { autoTitle, cleanTitle } from './titles.js';
+/** Events read per page while turning a run's events into messages. */
+const SYNC_PAGE = 500;
+function conversationConflict(reason, message) {
+    return new ProtocolError('CONVERSATION_CONFLICT', message, { reason });
+}
+function threadScopeOf(record) {
+    return `t${Number(record.thread)}`;
+}
+function subjectOf(id) {
+    return { kind: CONVERSATION_SUBJECT, id };
+}
+function encodeCursor(at, id) {
+    return Buffer.from(JSON.stringify([at, id]), 'utf8').toString('base64url');
+}
+function decodeCursor(cursor) {
+    try {
+        const value = JSON.parse(Buffer.from(cursor, 'base64url').toString('utf8'));
+        if (Array.isArray(value) &&
+            typeof value[0] === 'string' &&
+            typeof value[1] === 'string')
+            return { at: value[0], id: value[1] };
+    }
+    catch {
+        // Falls through to the error below.
+    }
+    throw invalid('pageToken is not one this API gave.', { field: 'pageToken' });
+}
+function limitOf(value, fallback, max) {
+    if (value === undefined)
+        return fallback;
+    return Math.min(Math.max(Math.trunc(value), 1), max);
+}
+/** The places conversations are started from besides the panel, as the application registers them. */
+function createSources() {
+    const sources = new Map();
+    return {
+        register(source) {
+            if (source.key === 'panel' ||
+                !CONVERSATION_SOURCE_PATTERN.test(source.key))
+                throw new Error(`Not a conversation source: ${source.key}`);
+            if (sources.has(source.key))
+                throw new Error(`Conversation source already registered: ${source.key}`);
+            sources.set(source.key, source);
+            return () => {
+                if (sources.get(source.key) === source)
+                    sources.delete(source.key);
+            };
+        },
+        has: (key) => sources.has(key),
+        list: () => [...sources.values()],
+    };
+}
+/** The conversation subject's names for its triggers in the run panel. */
+const CONVERSATION_TRIGGERS = {
+    message: { key: 'runs.trigger.message', ns: ACCESS_NAMESPACE },
+};
+/** The English text of a notice; the panel shows its own translation of `notice.code`. */
+function noticeText(notice, names) {
+    const name = (id) => names.get(id) ?? 'another agent';
+    switch (notice.code) {
+        case 'switchedToDefault':
+            return `This conversation now uses ${name(notice.agentId)}, the default agent, until you switch back to ${name(notice.fromAgentId)}.`;
+        case 'switchedToOnline':
+            return `${name(notice.fromAgentId)} has no runner for you now, so ${name(notice.agentId)} answers until you switch back.`;
+        case 'onlineFallbackUnavailable':
+            return `The online fallback agent cannot answer (${notice.reason}). This conversation stays with ${name(notice.fromAgentId)} while it waits for a runner.`;
+        case 'switchedBack':
+            return `This conversation is back with ${name(notice.agentId)}.`;
+        case 'runFailed':
+            return `The agent stopped before answering${notice.reason ? ` (${notice.reason})` : ''}.`;
+        case 'runCancelled':
+            return 'You stopped the agent.';
+        case 'news':
+            return notice.title;
+        case 'consultation':
+            return `Consulted ${notice.agentName}: ${notice.question}`;
+    }
+}
+function refOf(record) {
+    return {
+        id: record.id,
+        userId: record.userId,
+        agentId: record.agentId,
+        title: record.title,
+        source: record.source,
+    };
+}
+export function createConversationService(deps) {
+    const { tx, ids, clock } = deps;
+    const now = () => clock.now().toISOString();
+    /** A message as the API answers it, its files' URLs under the application's base path. */
+    const viewOf = (record) => toMessage(record, deps.basePath?.() ?? '');
+    const rules = [];
+    const sources = createSources();
+    // -------------------------------------------------------------------------------------------------------------------
+    // Reading
+    // -------------------------------------------------------------------------------------------------------------------
+    /** The conversation if `userId` owns it; 404 otherwise. */
+    async function owned(conn, userId, id) {
+        const record = await findConversation(conn, id);
+        if (!record || record.userId !== userId)
+            throw notFound('Conversation');
+        return record;
+    }
+    /** Locks the conversation if `userId` owns it; 404 otherwise. */
+    async function lockOwned(unit, userId, id) {
+        await owned(unit.conn, userId, id);
+        return (await lockConversation(unit.conn, id, now()));
+    }
+    function agentRef(id, agent) {
+        return {
+            id,
+            name: agent?.name ?? null,
+            nameText: agent?.nameText ?? null,
+            avatar: agent?.avatar ?? null,
+            archived: Boolean(agent?.archivedAt),
+        };
+    }
+    function runRef(runs) {
+        const run = runs[runs.length - 1];
+        return run
+            ? { id: run.id, status: run.status, acceptsInput: run.acceptsInput }
+            : null;
+    }
+    /** The entry the owner chose for the conversation, if any. */
+    function chosenModel(record) {
+        return record.modelService && record.model
+            ? { modelService: record.modelService, model: record.model }
+            : undefined;
+    }
+    /**
+     * The entry an online conversation answers with now (the system default chat model, `defaultModel`, for an agent
+     * that lists none); null for a runner one or a missing agent.
+     */
+    function modelOf(record, agent, defaultModel) {
+        if (record.mode !== 'online' || !agent)
+            return null;
+        return onlineEntryOf(agent, chosenModel(record), defaultModel);
+    }
+    async function summaries(conn, records, 
+    /** The system default chat model, when the caller has read it; read here when an online one needs it. */
+    known) {
+        const defaultModel = known !== undefined
+            ? known
+            : records.some((record) => record.mode === 'online')
+                ? ((await deps.models.catalog()).defaultModel ?? null)
+                : null;
+        const agents = new Map();
+        for (const record of records)
+            for (const id of [record.agentId, record.fallbackFromAgentId])
+                if (id && !agents.has(id))
+                    agents.set(id, await findAgent(conn, id));
+        const open = await openRunsOnEach(conn, CONVERSATION_SUBJECT, records.map((record) => record.id));
+        return records.map((record) => ({
+            id: record.id,
+            title: record.title,
+            titleSource: record.titleSource,
+            category: record.category,
+            source: record.source,
+            mode: record.mode,
+            agent: agentRef(record.agentId, agents.get(record.agentId) ?? null),
+            fallbackFrom: record.fallbackFromAgentId
+                ? agentRef(record.fallbackFromAgentId, agents.get(record.fallbackFromAgentId) ?? null)
+                : null,
+            model: modelOf(record, agents.get(record.agentId) ?? null, defaultModel),
+            read: Boolean(record.read),
+            lastMessageAt: record.lastMessageAt,
+            archivedAt: record.archivedAt,
+            createdAt: record.createdAt,
+            updatedAt: record.updatedAt,
+            run: runRef(open.filter((run) => run.subject.id === record.id)),
+        }));
+    }
+    async function systemDefault(conn, userId) {
+        const { defaultAgentId } = await deps.settings.settings(conn);
+        if (!defaultAgentId)
+            return null;
+        const agent = await findAgent(conn, defaultAgentId);
+        return wakeable(agent, userId, deps.agents.mayInvoke) ? agent : null;
+    }
+    /** The configured online agent and whether its default answering model is offered now. */
+    async function onlineFallback(conn, userId, catalog, settings) {
+        const { onlineFallbackAgentId } = settings ?? (await deps.settings.settings(conn));
+        if (!onlineFallbackAgentId)
+            return null;
+        const agent = await findAgent(conn, onlineFallbackAgentId);
+        const online = agent?.type === 'online' ? agent : null;
+        return {
+            agent: online,
+            availability: availabilityOf(online, userId, deps.agents.mayInvoke, 0, catalog),
+        };
+    }
+    /** Reads the same features and variable restrictions as claim, before any write transaction. */
+    async function availabilityFor(conn, agent, userId, catalog, wanted, runners) {
+        const eligible = agent?.type === 'runner' && wakeable(agent, userId, deps.agents.mayInvoke)
+            ? await deps.eligibility.runnersFor(conn, agent, {
+                actorUserId: userId,
+                ...(runners ? { runners } : {}),
+            })
+            : [];
+        return availabilityOf(agent, userId, deps.agents.mayInvoke, eligible.length, catalog, wanted);
+    }
+    async function canAnswer(conn, agent, userId, catalog) {
+        if (!wakeable(agent, userId, deps.agents.mayInvoke))
+            return false;
+        return agent.type === 'runner'
+            ? deps.eligibility.canClaim(conn, agent, { actorUserId: userId })
+            : availabilityOf(agent, userId, deps.agents.mayInvoke, 0, catalog).online;
+    }
+    async function automaticFallback(conn, agent, userId, catalog, settings) {
+        const current = settings ?? (await deps.settings.settings(conn));
+        if (!current.onlineFallbackAgentId ||
+            agent.type !== 'runner' ||
+            !wakeable(agent, userId, deps.agents.mayInvoke))
+            return null;
+        if (await deps.eligibility.canClaim(conn, agent, { actorUserId: userId }))
+            return null;
+        return onlineFallback(conn, userId, catalog, current);
+    }
+    /**
+     * The agent `fallback` switches the conversation to: an available system default of the conversation's mode, else,
+     * for a runner conversation, the online fallback agent. Null while it already uses another agent in place of its own.
+     */
+    async function fallbackTarget(conn, record, catalog) {
+        if (record.fallbackFromAgentId)
+            return null;
+        const system = await systemDefault(conn, record.userId);
+        if (system &&
+            system.id !== record.agentId &&
+            system.type === record.mode &&
+            (await canAnswer(conn, system, record.userId, catalog)))
+            return system;
+        if (record.mode !== 'runner')
+            return null;
+        const online = await onlineFallback(conn, record.userId, catalog);
+        return online?.availability.online && online.agent?.id !== record.agentId
+            ? online.agent
+            : null;
+    }
+    async function detailOf(conn, record) {
+        const catalog = await deps.models.catalog();
+        const [summary] = await summaries(conn, [record], catalog.defaultModel);
+        const agent = await findAgent(conn, record.agentId);
+        const fallbackFrom = record.fallbackFromAgentId
+            ? await findAgent(conn, record.fallbackFromAgentId)
+            : null;
+        const target = await fallbackTarget(conn, record, catalog);
+        return {
+            ...summary,
+            availability: await availabilityFor(conn, agent, record.userId, catalog, chosenModel(record)),
+            models: record.mode === 'online' && agent
+                ? chatModelChoices(onlineEntriesOrDefault(agent, catalog.defaultModel ?? null), catalog)
+                : [],
+            canFallback: Boolean(target),
+            canRestore: await canAnswer(conn, fallbackFrom, record.userId, catalog),
+        };
+    }
+    async function detail(userId, id) {
+        const conn = tx.read();
+        return detailOf(conn, await owned(conn, userId, id));
+    }
+    // -------------------------------------------------------------------------------------------------------------------
+    // Writing
+    // -------------------------------------------------------------------------------------------------------------------
+    function changed(unit, record, lastSeq) {
+        unit.emit({
+            type: 'conversation.changed',
+            conversationId: record.id,
+            userId: record.userId,
+            ...(lastSeq === undefined ? {} : { lastSeq }),
+        });
+    }
+    async function append(unit, record, message) {
+        const appended = await appendMessage(unit.conn, ids, record.id, message, now());
+        changed(unit, record, Number(appended.seq));
+        return appended;
+    }
+    async function notice(unit, record, value, runId = null) {
+        const agentIds = value.code === 'switchedToDefault' ||
+            value.code === 'switchedToOnline' ||
+            value.code === 'switchedBack'
+            ? [value.agentId, value.fromAgentId]
+            : value.code === 'onlineFallbackUnavailable'
+                ? [value.fromAgentId]
+                : [];
+        const names = new Map();
+        for (const id of agentIds) {
+            const agent = await findAgent(unit.conn, id);
+            if (agent)
+                names.set(id, agent.name);
+        }
+        await append(unit, record, {
+            role: 'system',
+            text: noticeText(value, names),
+            metadata: { notice: value },
+            runId,
+        });
+    }
+    async function nameOf(conn, userId) {
+        return (await deps.people.names(conn, [userId])).get(userId) ?? userId;
+    }
+    /** Remember the last fallback failure in the transcript, across requests and application restarts. */
+    async function fallbackFailureNotice(unit, record, value) {
+        const previous = await messagesRepo(unit.conn).findOne({
+            filter: (f) => f.and([
+                f.string('conversationId').eq(record.id),
+                f.string('role').eq('system'),
+                f
+                    .json('metadata')
+                    .path(['notice', 'code'])
+                    .eq('onlineFallbackUnavailable'),
+            ]),
+            sort: (sort) => sort.field('seq').desc(),
+        });
+        const metadata = previous ? metadataOf(previous) : null;
+        const last = metadata?.notice;
+        if (value &&
+            !metadata?.onlineFallbackResolved &&
+            last?.code === 'onlineFallbackUnavailable' &&
+            last.fromAgentId === value.fromAgentId &&
+            last.reason === value.reason)
+            return;
+        if (previous && !metadata?.onlineFallbackResolved)
+            await messagesRepo(unit.conn).updateMany({
+                filter: { id: previous.id },
+                values: {
+                    metadata: asJson({ ...metadata, onlineFallbackResolved: true }),
+                    updatedAt: now(),
+                },
+            });
+        if (value)
+            await notice(unit, record, value);
+    }
+    /** The run input a user message becomes: its text, its files, and its page context marked as data. */
+    function inputText(message) {
+        const view = toMessage(message);
+        const context = view.workContext;
+        return [
+            view.content.content.trim(),
+            attachmentLines(storedAttachments(message.attachments)),
+            hasContent(context) ? renderPageContext(context) : '',
+        ]
+            .filter((part) => part !== '')
+            .join('\n\n');
+    }
+    /** Hands user messages to the conversation's agent, oldest first. */
+    async function wake(unit, record, messages) {
+        const agent = await findAgent(unit.conn, record.agentId);
+        if (!wakeable(agent, record.userId, deps.agents.mayInvoke))
+            return null;
+        const name = await nameOf(unit.conn, record.userId);
+        let result = null;
+        for (const message of messages) {
+            const files = storedAttachments(message.attachments);
+            const enqueued = await deps.runs.enqueue({
+                agentId: agent.id,
+                subject: subjectOf(record.id),
+                threadScope: threadScopeOf(record),
+                actorUserId: record.userId,
+                ownerUserId: record.userId,
+                input: {
+                    type: 'comment',
+                    actor: { kind: 'user', id: record.userId, name },
+                    text: inputText(message),
+                    payload: {
+                        trigger: 'message',
+                        conversationId: record.id,
+                        messageId: message.id,
+                        seq: Number(message.seq),
+                        // An online agent's executor shows the images among them to its model.
+                        ...(files.length > 0
+                            ? { attachmentIds: files.map((file) => file.id) }
+                            : {}),
+                    },
+                },
+            }, unit);
+            await updateMessageRun(unit.conn, message, enqueued.runId, { inputId: enqueued.inputId }, now());
+            result = { id: enqueued.runId, outcome: enqueued.outcome };
+        }
+        return result;
+    }
+    /**
+     * Moves the conversation to `agent`: its queued work is withdrawn, the thread moves on (a new session), and the
+     * messages nobody answered go to the new agent. The mode follows the agent's type; a model chosen for an online
+     * conversation is dropped when it changes.
+     */
+    async function rebind(unit, record, agent, fallbackFromAgentId, value) {
+        const withdrawn = await deps.runs.withdrawQueued({ subject: subjectOf(record.id), byUserId: record.userId }, unit);
+        await conversationsRepo(unit.conn).updateMany({
+            filter: { id: record.id },
+            values: {
+                agentId: agent.id,
+                mode: agent.type,
+                ...(agent.type === record.mode
+                    ? {}
+                    : { modelService: null, model: null }),
+                fallbackFromAgentId,
+                thread: Number(record.thread) + 1,
+                updatedAt: now(),
+            },
+        });
+        const moved = (await findConversation(unit.conn, record.id));
+        const runIds = withdrawn.map((run) => run.id);
+        const unanswered = await messagesRepo(unit.conn).findMany({
+            filter: (f) => f.and([
+                f.string('conversationId').eq(record.id),
+                f.string('role').eq('user'),
+                f.or([
+                    f.string('runId').empty(),
+                    ...runIds.map((id) => f.string('runId').eq(id)),
+                ]),
+            ]),
+            sort: (sort) => sort.field('seq').asc(),
+        });
+        await notice(unit, moved, value);
+        await wake(unit, moved, unanswered);
+    }
+    // -------------------------------------------------------------------------------------------------------------------
+    // Turning run events into messages
+    // -------------------------------------------------------------------------------------------------------------------
+    /** Appends the run's new text events as assistant messages, in the caller's transaction. */
+    async function syncIn(unit, run) {
+        if (run.subject.kind !== CONVERSATION_SUBJECT)
+            return;
+        const record = await lockConversation(unit.conn, run.subject.id, now());
+        if (!record || record.userId !== run.actorUserId)
+            return;
+        let after;
+        if (record.syncRunId === run.id)
+            after = Number(record.syncSeq);
+        else {
+            const last = await messagesRepo(unit.conn).findOne({
+                filter: (f) => f.and([
+                    f.string('runId').eq(run.id),
+                    f.number('runEventSeq').notEmpty(),
+                ]),
+                sort: (sort) => sort.field('runEventSeq').desc(),
+            });
+            after = last ? Number(last.runEventSeq) : 0;
+        }
+        const start = after;
+        for (;;) {
+            const events = await eventsAfter(unit.conn, run.id, after, SYNC_PAGE);
+            for (const event of events) {
+                after = Number(event.seq);
+                const text = event.type === 'text' ? (event.content ?? '') : '';
+                if (text.trim() === '')
+                    continue;
+                const metadata = {
+                    agentId: run.agentId,
+                    runEventSeq: Number(event.seq),
+                };
+                // An online agent's draft of this text becomes the final message, where the person watched it grow.
+                const draft = await findDraft(unit.conn, record.id, run.id);
+                if (draft) {
+                    await rewriteMessage(unit.conn, draft, { text, metadata, runEventSeq: Number(event.seq) }, now());
+                    changed(unit, record, Number(draft.seq));
+                    continue;
+                }
+                await append(unit, record, {
+                    role: 'assistant',
+                    text,
+                    runId: run.id,
+                    runEventSeq: Number(event.seq),
+                    metadata,
+                    at: event.at,
+                });
+            }
+            if (events.length < SYNC_PAGE)
+                break;
+        }
+        if (after !== start || record.syncRunId !== run.id)
+            await conversationsRepo(unit.conn).updateMany({
+                filter: { id: record.id },
+                values: { syncRunId: run.id, syncSeq: after },
+            });
+    }
+    // -------------------------------------------------------------------------------------------------------------------
+    // The run subject
+    // -------------------------------------------------------------------------------------------------------------------
+    /** A run's assembly in `conversation`, as its owner (`ownerName`) left it: `history` the messages before its inputs. */
+    async function conversationAssembly(conn, claim, conversation, ownerName, history, previousSummary, chosen) {
+        const key = conversationKey(conversation.id);
+        const added = await Promise.all(rules.map((source) => source(conn, {
+            conversation: {
+                id: conversation.id,
+                userId: conversation.userId,
+                agentId: conversation.agentId,
+                title: conversation.title,
+                source: conversation.source,
+            },
+            agent: claim.agent,
+            ownerName,
+            cli: claim.cli,
+            dialect: claim.dialect,
+        })));
+        return {
+            subject: {
+                key,
+                ...(conversation.title ? { title: conversation.title } : {}),
+                url: conversationUrl(conversation.id),
+                noun: 'conversation',
+            },
+            system: conversationSystemLayer({
+                agentName: claim.agent.name,
+                ownerName,
+                key,
+                cli: claim.cli,
+                appName: claim.appName,
+                dialect: claim.dialect,
+                rules: added.flatMap((lines) => lines.rules ?? []),
+                sections: added.flatMap((lines) => lines.sections ?? []),
+            }),
+            task: conversationTask({
+                key,
+                title: conversation.title,
+                ownerName,
+            }),
+            context: conversationContext({
+                title: conversation.title,
+                startedAt: conversation.createdAt,
+                history,
+            }),
+            turn: {
+                prompt: conversationTurn(claim.inputs.length),
+                ...(previousSummary ? { previousSummary } : {}),
+            },
+            data: {
+                kind: CONVERSATION_SUBJECT,
+                conversation: {
+                    id: conversation.id,
+                    title: conversation.title,
+                    ownerUserId: conversation.userId,
+                    source: conversation.source,
+                },
+            },
+            dirs: [],
+            scopes: [],
+            ...(chosen ? { model: chosen } : {}),
+        };
+    }
+    const binding = {
+        kind: CONVERSATION_SUBJECT,
+        private: true,
+        // A conversation needs no working directory: online agents answer in it as well as runner agents.
+        agentTypes: ['online', 'runner'],
+        title: { key: 'subjects.conversation', ns: ACCESS_NAMESPACE },
+        triggers: CONVERSATION_TRIGGERS,
+        // "Preview full prompt": a new conversation of the previewer's, with one message, both made up.
+        preview: {
+            inputs: (user, at) => [
+                {
+                    id: 'preview',
+                    type: 'comment',
+                    at,
+                    actor: { kind: 'user', id: user.id, name: user.name },
+                    text: sampleValue('What is waiting for me this week?'),
+                    payload: { trigger: 'message' },
+                },
+            ],
+            async assemble(conn, claim) {
+                return conversationAssembly(conn, claim, {
+                    id: claim.run.subject.id,
+                    userId: claim.run.actorUserId ?? '',
+                    agentId: claim.agent.id,
+                    title: sampleValue('This week'),
+                    source: 'panel',
+                    createdAt: claim.run.createdAt,
+                }, await nameOf(conn, claim.run.actorUserId ?? ''), [], null, null);
+            },
+        },
+        context: {
+            async assemble(conn, claim) {
+                const record = await findConversation(conn, claim.run.subject.id);
+                // Only the owner's runs see a conversation (a preview by anyone else, too, finds nothing).
+                if (!record || record.userId !== claim.run.actorUserId)
+                    throw new Error('The conversation is gone.');
+                const ownerName = await nameOf(conn, record.userId);
+                const fresh = !claim.runner ||
+                    !(await hasSession(conn, {
+                        agentId: claim.agent.id,
+                        runnerId: claim.runner.id,
+                        subjectKind: CONVERSATION_SUBJECT,
+                        subjectId: record.id,
+                        threadScope: claim.run.threadScope,
+                    }));
+                const pending = new Set(claim.inputs.flatMap((input) => {
+                    const payload = input.payload;
+                    return typeof payload?.messageId === 'string'
+                        ? [payload.messageId]
+                        : [];
+                }));
+                let history = [];
+                if (fresh) {
+                    const recent = await messagesRepo(conn).findMany({
+                        filter: { conversationId: record.id },
+                        sort: (sort) => sort.field('seq').desc(),
+                        limit: CONVERSATION_HISTORY_IN_PROMPT + pending.size,
+                    });
+                    history = recent
+                        .filter((message) => !pending.has(message.id))
+                        .slice(0, CONVERSATION_HISTORY_IN_PROMPT)
+                        .reverse()
+                        .map((message) => {
+                        const view = toMessage(message);
+                        return {
+                            role: view.role,
+                            author: view.role === 'user'
+                                ? ownerName
+                                : view.role === 'assistant'
+                                    ? claim.agent.name
+                                    : claim.appName,
+                            at: view.createdAt,
+                            text: [
+                                view.content.content,
+                                attachmentLines(storedAttachments(message.attachments)),
+                            ]
+                                .filter((part) => part.trim() !== '')
+                                .join('\n\n'),
+                        };
+                    });
+                }
+                const previousSummary = fresh
+                    ? await lastSummary(conn, {
+                        agentId: claim.agent.id,
+                        subjectKind: CONVERSATION_SUBJECT,
+                        subjectId: record.id,
+                    }, claim.run.id)
+                    : null;
+                return conversationAssembly(conn, claim, { ...refOf(record), createdAt: record.createdAt }, ownerName, history, previousSummary, chosenModel(record) ?? null);
+            },
+        },
+        sink: {
+            async onRunFinished(unit, run) {
+                await syncIn(unit, run);
+                const record = await findConversation(unit.conn, run.subject.id);
+                if (!record || record.userId !== run.actorUserId)
+                    return;
+                // A consultation card the run never closed (the instance stopped) ends as failed.
+                for (const message of await messagesRepo(unit.conn).findMany({
+                    filter: { conversationId: record.id, runId: run.id, role: 'system' },
+                })) {
+                    const { streaming, ...kept } = metadataOf(message);
+                    if (!streaming || kept.notice?.code !== 'consultation')
+                        continue;
+                    await rewriteMessage(unit.conn, message, {
+                        text: toMessage(message).content.content,
+                        metadata: {
+                            ...kept,
+                            notice: {
+                                ...kept.notice,
+                                state: 'failed',
+                                error: 'The consultation ended with the run that asked it.',
+                            },
+                        },
+                    }, now());
+                    changed(unit, record, Number(message.seq));
+                }
+                // A draft the run never made final keeps what it had written.
+                const draft = await findDraft(unit.conn, record.id, run.id);
+                if (draft) {
+                    const { streaming: _streaming, ...kept } = metadataOf(draft);
+                    await rewriteMessage(unit.conn, draft, {
+                        text: toMessage(draft).content.content,
+                        metadata: { ...kept, interrupted: true },
+                    }, now());
+                    changed(unit, record, Number(draft.seq));
+                }
+                if (run.status !== 'failed')
+                    return;
+                await notice(unit, record, { code: 'runFailed', runId: run.id, reason: run.failureReason }, run.id);
+            },
+        },
+    };
+    // -------------------------------------------------------------------------------------------------------------------
+    // The service
+    // -------------------------------------------------------------------------------------------------------------------
+    async function pickAgent(conn, userId, requested) {
+        if (requested) {
+            const agent = await findAgent(conn, requested);
+            if (!agent)
+                throw invalid('agentId names no agent.', { field: 'agentId' });
+            if (!wakeable(agent, userId, deps.agents.mayInvoke))
+                throw forbidden('You may not chat with this agent.');
+            return agent;
+        }
+        const { defaultAgentId } = await deps.settings.preferences(userId, conn);
+        if (defaultAgentId) {
+            const mine = await findAgent(conn, defaultAgentId);
+            if (wakeable(mine, userId, deps.agents.mayInvoke))
+                return mine;
+        }
+        const system = await systemDefault(conn, userId);
+        if (system)
+            return system;
+        throw conversationConflict('noChatAgent', 'There is no agent to chat with: pick one, or ask an administrator to set the default chat agent.');
+    }
+    function titleFor(value, max) {
+        const { text, length } = cleanTitle(value);
+        if (length === 0 || length > max)
+            throw invalid(`title must be 1 to ${max} characters.`);
+        return text;
+    }
+    async function sendMessage(userId, id, request) {
+        const content = request.content;
+        const attachmentIds = readAttachmentIds(request.attachmentIds);
+        if (typeof content !== 'string' ||
+            (content.trim() === '' && attachmentIds.length === 0) ||
+            [...content].length > MESSAGE_CONTENT_MAX)
+            throw invalid(`content must be 1 to ${MESSAGE_CONTENT_MAX} characters, or empty with files.`);
+        const links = deps.attachments;
+        if (attachmentIds.length > 0 && !links)
+            throw invalid('This application takes no files in chat.', {
+                field: 'attachmentIds',
+            });
+        const before = await owned(tx.read(), userId, id);
+        const agent = before.mode === 'runner'
+            ? await findAgent(tx.read(), before.agentId)
+            : null;
+        const replacement = agent
+            ? await automaticFallback(tx.read(), agent, userId, await deps.models.catalog())
+            : null;
+        // Resolved before the transaction: resolvers read through the services of the plugins that own the kinds.
+        const context = request.context
+            ? await deps.contextKinds.resolve(tx.read(), userId, request.context)
+            : null;
+        const sent = await tx.run(async (unit) => {
+            let record = await lockOwned(unit, userId, id);
+            let fallbackFailure = null;
+            // A concurrent switch owns its new binding; do not apply a decision made for the previous one.
+            if (replacement &&
+                record.agentId === before.agentId &&
+                record.thread === before.thread &&
+                record.mode === 'runner' &&
+                record.fallbackFromAgentId === before.fallbackFromAgentId) {
+                const current = await findAgent(unit.conn, record.agentId);
+                const target = replacement.agent
+                    ? await findAgent(unit.conn, replacement.agent.id)
+                    : null;
+                if (current?.revision === agent?.revision &&
+                    replacement.availability.online &&
+                    wakeable(target, userId, deps.agents.mayInvoke) &&
+                    target.revision === replacement.agent?.revision) {
+                    await rebind(unit, record, target, record.fallbackFromAgentId ?? record.agentId, {
+                        code: 'switchedToOnline',
+                        agentId: target.id,
+                        fromAgentId: record.agentId,
+                    });
+                    record = (await findConversation(unit.conn, id));
+                }
+                else if (current?.revision === agent?.revision &&
+                    replacement.availability.reason) {
+                    fallbackFailure = {
+                        code: 'onlineFallbackUnavailable',
+                        fromAgentId: record.agentId,
+                        reason: replacement.availability.reason,
+                    };
+                }
+            }
+            await fallbackFailureNotice(unit, record, fallbackFailure);
+            const at = now();
+            if (record.archivedAt || (record.titleSource === 'auto' && !record.title))
+                await conversationsRepo(unit.conn).updateMany({
+                    filter: { id },
+                    values: {
+                        archivedAt: null,
+                        ...(record.titleSource === 'auto' && !record.title
+                            ? {
+                                title: autoTitle(content, CONVERSATION_TITLE_AUTO_CHARS) || null,
+                            }
+                            : {}),
+                        updatedAt: at,
+                    },
+                });
+            let message = await append(unit, record, {
+                role: 'user',
+                text: content,
+                workContext: context,
+                metadata: request.clientId ? { clientId: request.clientId } : {},
+            });
+            if (links && attachmentIds.length > 0) {
+                const files = await links.attach(unit.conn, userId, { conversationId: id, messageId: message.id }, attachmentIds);
+                await messagesRepo(unit.conn).updateMany({
+                    filter: { id: message.id },
+                    values: { attachments: asJson(files) },
+                });
+                message = (await messagesRepo(unit.conn).findOne({
+                    filter: { id: message.id },
+                }));
+            }
+            const run = await wake(unit, record, [message]);
+            await conversationsRepo(unit.conn).updateMany({
+                filter: { id },
+                values: { read: true },
+            });
+            return {
+                run,
+                message: (await messagesRepo(unit.conn).findOne({
+                    filter: { id: message.id },
+                })),
+            };
+        });
+        return {
+            message: viewOf(sent.message),
+            run: sent.run,
+            conversation: await detail(userId, id),
+        };
+    }
+    const service = {
+        binding,
+        contextKinds: deps.contextKinds,
+        sources,
+        async list(userId, query) {
+            const conn = tx.read();
+            const limit = limitOf(query.pageSize, CONVERSATION_PAGE_DEFAULT, CONVERSATION_PAGE_MAX);
+            const cursor = query.pageToken ? decodeCursor(query.pageToken) : null;
+            const q = query.q?.trim();
+            const rows = await conversationsRepo(conn).findMany({
+                filter: (f) => f.and([
+                    f.string('userId').eq(userId),
+                    ...(query.archived === 'all'
+                        ? []
+                        : [
+                            query.archived
+                                ? f.date('archivedAt').notEmpty()
+                                : f.date('archivedAt').empty(),
+                        ]),
+                    ...(query.agentId ? [f.string('agentId').eq(query.agentId)] : []),
+                    ...(query.source ? [f.string('source').eq(query.source)] : []),
+                    ...(q
+                        ? [
+                            f.or([
+                                f.string('title').includes(q, { mode: 'insensitive' }),
+                                f
+                                    .relation('messages')
+                                    .some((message) => message
+                                    .text('searchText')
+                                    .includes(q, { mode: 'insensitive' })),
+                            ]),
+                        ]
+                        : []),
+                    ...(cursor ? [f.date('lastMessageAt').notAfter(cursor.at)] : []),
+                ]),
+                sort: (sort) => [
+                    sort.field('lastMessageAt').desc(),
+                    sort.field('id').desc(),
+                ],
+                // Rows tied with the cursor's time that the previous page showed are skipped below.
+                limit: limit + 1 + (cursor ? 50 : 0),
+            });
+            const after = cursor
+                ? rows.filter((row) => Date.parse(row.lastMessageAt) < Date.parse(cursor.at) ||
+                    (Date.parse(row.lastMessageAt) === Date.parse(cursor.at) &&
+                        row.id < cursor.id))
+                : rows;
+            const page = after.slice(0, limit);
+            const last = page[page.length - 1];
+            return {
+                items: await summaries(conn, page),
+                nextCursor: after.length > limit && last
+                    ? encodeCursor(last.lastMessageAt, last.id)
+                    : null,
+            };
+        },
+        async create(userId, request) {
+            const wanted = request.model ?? null;
+            // Read before the transaction, which a read on another connection would wait for.
+            const catalog = await deps.models.catalog();
+            const fallback = catalog.defaultModel ?? null;
+            const settings = await deps.settings.settings();
+            const picked = await pickAgent(tx.read(), userId, request.agentId);
+            const replacement = !wanted
+                ? await automaticFallback(tx.read(), picked, userId, catalog, settings)
+                : null;
+            const id = await tx.run(async (unit) => {
+                const current = await pickAgent(unit.conn, userId, request.agentId);
+                const target = replacement?.agent
+                    ? await findAgent(unit.conn, replacement.agent.id)
+                    : null;
+                const instead = current.id === picked.id &&
+                    current.revision === picked.revision &&
+                    replacement?.availability.online &&
+                    wakeable(target, userId, deps.agents.mayInvoke) &&
+                    target.revision === replacement.agent?.revision
+                    ? target
+                    : null;
+                const agent = instead ?? current;
+                if (wanted &&
+                    (agent.type !== 'online' ||
+                        !onlineEntriesOrDefault(agent, fallback).some((entry) => sameEntry(entry, wanted))))
+                    throw invalid(`The agent does not list the model ${wanted.modelService} · ${wanted.model}.`, { reason: 'MODEL_NOT_LISTED' });
+                const title = request.title === undefined
+                    ? null
+                    : titleFor(request.title, CONVERSATION_TITLE_MAX);
+                const at = now();
+                const source = request.source ?? 'panel';
+                if (source !== 'panel' && !sources.has(source))
+                    throw invalid(`${source} is not a source conversations start from.`);
+                const conversationId = ids.next();
+                await conversationsRepo(unit.conn).createOne({
+                    values: {
+                        id: conversationId,
+                        userId,
+                        agentId: agent.id,
+                        mode: agent.type,
+                        fallbackFromAgentId: instead ? picked.id : null,
+                        modelService: wanted?.modelService ?? null,
+                        model: wanted?.model ?? null,
+                        title,
+                        titleSource: title ? 'user' : 'auto',
+                        category: 'chat',
+                        source,
+                        read: true,
+                        thread: 0,
+                        lastSeq: 0,
+                        syncRunId: null,
+                        syncSeq: 0,
+                        lastMessageAt: at,
+                        archivedAt: null,
+                        lockedAt: null,
+                        createdAt: at,
+                        updatedAt: at,
+                    },
+                });
+                const record = (await findConversation(unit.conn, conversationId));
+                if (instead)
+                    await notice(unit, record, {
+                        code: 'switchedToOnline',
+                        agentId: instead.id,
+                        fromAgentId: picked.id,
+                    });
+                else if (replacement?.availability.reason)
+                    await notice(unit, record, {
+                        code: 'onlineFallbackUnavailable',
+                        fromAgentId: picked.id,
+                        reason: replacement.availability.reason,
+                    });
+                else
+                    changed(unit, record);
+                return conversationId;
+            });
+            return detail(userId, id);
+        },
+        get: detail,
+        async update(userId, id, patch) {
+            // Read before the transaction, which a read on another connection would wait for.
+            const fallback = patch.model !== undefined && patch.model !== null
+                ? ((await deps.models.catalog()).defaultModel ?? null)
+                : null;
+            await tx.run(async (unit) => {
+                const record = await lockOwned(unit, userId, id);
+                const values = {};
+                if (patch.title !== undefined) {
+                    values.title = titleFor(patch.title, CONVERSATION_TITLE_MAX);
+                    values.titleSource = 'user';
+                }
+                if (patch.archived !== undefined)
+                    values.archivedAt = patch.archived
+                        ? (record.archivedAt ?? now())
+                        : null;
+                if (patch.model !== undefined) {
+                    const wanted = patch.model;
+                    if (wanted !== null) {
+                        const agent = await findAgent(unit.conn, record.agentId);
+                        if (record.mode !== 'online' ||
+                            !agent ||
+                            !onlineEntriesOrDefault(agent, fallback).some((entry) => sameEntry(entry, wanted)))
+                            throw invalid(`The agent does not list the model ${wanted.modelService} · ${wanted.model}.`, { reason: 'MODEL_NOT_LISTED' });
+                    }
+                    values.modelService = wanted?.modelService ?? null;
+                    values.model = wanted?.model ?? null;
+                }
+                if (Object.keys(values).length === 0)
+                    return;
+                await conversationsRepo(unit.conn).updateMany({
+                    filter: { id },
+                    values: { ...values, updatedAt: now() },
+                });
+                changed(unit, record);
+            });
+            return detail(userId, id);
+        },
+        async messages(userId, id, query) {
+            const conn = tx.read();
+            const record = await owned(conn, userId, id);
+            const limit = limitOf(query.limit, MESSAGE_PAGE_DEFAULT, MESSAGE_PAGE_MAX);
+            const current = (await findConversation(conn, id)) ?? record;
+            let rows;
+            let hasMore;
+            if (query.after !== undefined) {
+                rows = await messagesRepo(conn).findMany({
+                    filter: (f) => f.and([
+                        f.string('conversationId').eq(id),
+                        f.number('seq').gt(query.after),
+                    ]),
+                    sort: (sort) => sort.field('seq').asc(),
+                    limit,
+                });
+                const first = rows[0];
+                hasMore = first ? Number(first.seq) > 1 : Number(current.lastSeq) > 0;
+            }
+            else {
+                const newest = await messagesRepo(conn).findMany({
+                    filter: (f) => f.and([
+                        f.string('conversationId').eq(id),
+                        ...(query.before !== undefined
+                            ? [f.number('seq').lt(query.before)]
+                            : []),
+                    ]),
+                    sort: (sort) => sort.field('seq').desc(),
+                    limit: limit + 1,
+                });
+                hasMore = newest.length > limit;
+                rows = newest.slice(0, limit).reverse();
+            }
+            return {
+                items: rows.map((row) => viewOf(row)),
+                hasMore,
+                lastSeq: Number(current.lastSeq),
+            };
+        },
+        send: (userId, id, request) => sendMessage(userId, id, request),
+        async start(userId, request) {
+            if (!sources.has(request.source))
+                throw invalid(`source must be one of ${sources
+                    .list()
+                    .map((source) => source.key)
+                    .join(', ') || '(none registered)'}.`);
+            if (typeof request.text !== 'string' || request.text.trim() === '')
+                throw invalid('text is required.');
+            if ([...request.text].length > MESSAGE_CONTENT_MAX)
+                throw invalid(`The text is longer than a message may be (${MESSAGE_CONTENT_MAX} characters).`);
+            const conversation = await service.create(userId, {
+                ...(request.agentId ? { agentId: request.agentId } : {}),
+                ...(request.title ? { title: request.title } : {}),
+                source: request.source,
+            });
+            return sendMessage(userId, conversation.id, {
+                content: request.text,
+                ...(request.context ? { context: request.context } : {}),
+                ...(request.clientId ? { clientId: request.clientId } : {}),
+            });
+        },
+        async markRead(userId, id) {
+            await tx.run(async (unit) => {
+                const record = await lockOwned(unit, userId, id);
+                if (record.read)
+                    return;
+                await conversationsRepo(unit.conn).updateMany({
+                    filter: { id },
+                    values: { read: true },
+                });
+                changed(unit, record);
+            });
+            return detail(userId, id);
+        },
+        async stop(userId, id) {
+            await tx.run(async (unit) => {
+                const record = await lockOwned(unit, userId, id);
+                const open = await openRunsOnEach(unit.conn, CONVERSATION_SUBJECT, [
+                    id,
+                ]);
+                for (const run of open) {
+                    await deps.runs.cancel(run.id, userId, unit);
+                    await notice(unit, record, { code: 'runCancelled', runId: run.id }, run.id);
+                }
+            });
+            return detail(userId, id);
+        },
+        async fallback(userId, id) {
+            const catalog = await deps.models.catalog();
+            const before = await owned(tx.read(), userId, id);
+            const target = await fallbackTarget(tx.read(), before, catalog);
+            await tx.run(async (unit) => {
+                const record = await lockOwned(unit, userId, id);
+                const current = target ? await findAgent(unit.conn, target.id) : null;
+                if (!target ||
+                    !wakeable(current, userId, deps.agents.mayInvoke) ||
+                    current.revision !== target.revision ||
+                    record.agentId !== before.agentId ||
+                    record.thread !== before.thread ||
+                    record.fallbackFromAgentId !== before.fallbackFromAgentId)
+                    throw conversationConflict('noFallback', 'This conversation cannot switch to another agent.');
+                await rebind(unit, record, current, record.agentId, {
+                    code: target.type === record.mode
+                        ? 'switchedToDefault'
+                        : 'switchedToOnline',
+                    agentId: target.id,
+                    fromAgentId: record.agentId,
+                });
+            });
+            return detail(userId, id);
+        },
+        async restore(userId, id) {
+            const before = await owned(tx.read(), userId, id);
+            const own = before.fallbackFromAgentId
+                ? await findAgent(tx.read(), before.fallbackFromAgentId)
+                : null;
+            const available = await canAnswer(tx.read(), own, userId, await deps.models.catalog());
+            await tx.run(async (unit) => {
+                const record = await lockOwned(unit, userId, id);
+                const current = own ? await findAgent(unit.conn, own.id) : null;
+                if (!own ||
+                    !available ||
+                    !wakeable(current, userId, deps.agents.mayInvoke) ||
+                    current.revision !== own.revision ||
+                    record.agentId !== before.agentId ||
+                    record.thread !== before.thread ||
+                    record.fallbackFromAgentId !== own.id)
+                    throw conversationConflict('noRestore', 'This conversation cannot switch back to its own agent now.');
+                await rebind(unit, record, current, null, {
+                    code: 'switchedBack',
+                    agentId: own.id,
+                    fromAgentId: record.agentId,
+                });
+            });
+            return detail(userId, id);
+        },
+        async setTitleFromRun(run, title) {
+            const conversation = await tx.run(async (unit) => {
+                if (run.subject.kind !== CONVERSATION_SUBJECT)
+                    throw notFound('Conversation');
+                const record = await lockConversation(unit.conn, run.subject.id, now());
+                if (!record || record.userId !== run.actorUserId)
+                    throw notFound('Conversation');
+                if (record.titleSource === 'user')
+                    throw conversationConflict('titleLocked', 'The person renamed this conversation; keep their title.');
+                await conversationsRepo(unit.conn).updateMany({
+                    filter: { id: record.id },
+                    values: {
+                        title: titleFor(title, CONVERSATION_TITLE_AGENT_MAX),
+                        titleSource: 'agent',
+                        updatedAt: now(),
+                    },
+                });
+                changed(unit, record);
+                return record;
+            });
+            return detail(conversation.userId, conversation.id);
+        },
+        async ofRun(conn, run) {
+            if (run.subject.kind !== CONVERSATION_SUBJECT)
+                return null;
+            const record = await findConversation(conn, run.subject.id);
+            if (!record || record.userId !== run.actorUserId)
+                return null;
+            return refOf(record);
+        },
+        async homeOf(conn, run) {
+            let current = run;
+            // A consultation's chain is short (`CONSULT_MAX_DEPTH`); a broken link ends it.
+            for (let hop = 0; current.parentRunId && hop <= CONSULT_MAX_DEPTH; hop += 1) {
+                const parent = await findRunRecord(conn, current.parentRunId);
+                if (!parent || parent.actorUserId !== run.actorUserId)
+                    return null;
+                current = toRun(parent);
+            }
+            if (current.parentRunId || current.subject.kind !== CONVERSATION_SUBJECT)
+                return null;
+            const record = await findConversation(conn, current.subject.id);
+            if (!record || record.userId !== run.actorUserId)
+                return null;
+            return refOf(record);
+        },
+        async consultation(run, card) {
+            if (run.subject.kind !== CONVERSATION_SUBJECT)
+                return;
+            await tx.run(async (unit) => {
+                const record = await lockConversation(unit.conn, run.subject.id, now());
+                if (!record || record.userId !== run.actorUserId)
+                    return;
+                const metadata = {
+                    notice: card,
+                    ...(card.agentId ? { agentId: card.agentId } : {}),
+                    ...(card.state === 'running' ? { streaming: true } : {}),
+                };
+                const existing = (await messagesRepo(unit.conn).findMany({
+                    filter: {
+                        conversationId: record.id,
+                        runId: run.id,
+                        role: 'system',
+                    },
+                })).find((message) => {
+                    const notice = metadataOf(message).notice;
+                    return (notice?.code === 'consultation' && notice.callId === card.callId);
+                });
+                if (existing) {
+                    await rewriteMessage(unit.conn, existing, { text: noticeText(card, new Map()), metadata }, now());
+                    changed(unit, record, Number(existing.seq));
+                    return;
+                }
+                await append(unit, record, {
+                    role: 'system',
+                    text: noticeText(card, new Map()),
+                    metadata,
+                    runId: run.id,
+                });
+            });
+        },
+        async deliver(outer, conversationId, news) {
+            const record = await lockConversation(outer.conn, conversationId, now());
+            if (!record)
+                return null;
+            await notice(outer, record, news.notice);
+            if (!news.input)
+                return null;
+            const agent = await findAgent(outer.conn, record.agentId);
+            if (!wakeable(agent, record.userId, deps.agents.mayInvoke))
+                return null;
+            const enqueued = await deps.runs.enqueue({
+                agentId: agent.id,
+                subject: subjectOf(record.id),
+                threadScope: threadScopeOf(record),
+                actorUserId: record.userId,
+                ownerUserId: record.userId,
+                input: news.input,
+            }, outer);
+            return { id: enqueued.runId, outcome: enqueued.outcome };
+        },
+        lock: async (conn, id) => (await lockConversation(conn, id, now())) !== null,
+        rules: {
+            provide(source) {
+                rules.push(source);
+                return () => {
+                    const at = rules.indexOf(source);
+                    if (at >= 0)
+                        rules.splice(at, 1);
+                };
+            },
+        },
+        async syncRun(runId) {
+            const run = await deps.runs.get(runId);
+            if (run.subject.kind !== CONVERSATION_SUBJECT)
+                return;
+            await tx.run((unit) => syncIn(unit, run));
+        },
+        async streamDraft(run, text) {
+            if (run.subject.kind !== CONVERSATION_SUBJECT)
+                return;
+            await tx.run(async (unit) => {
+                const record = await lockConversation(unit.conn, run.subject.id, now());
+                if (!record || record.userId !== run.actorUserId)
+                    return;
+                const draft = await findDraft(unit.conn, record.id, run.id);
+                if (draft) {
+                    await rewriteMessage(unit.conn, draft, {
+                        text,
+                        metadata: { ...metadataOf(draft), streaming: true },
+                    }, now());
+                    changed(unit, record, Number(draft.seq));
+                    return;
+                }
+                if (text.trim() === '')
+                    return;
+                await append(unit, record, {
+                    role: 'assistant',
+                    text,
+                    runId: run.id,
+                    metadata: { agentId: run.agentId, streaming: true },
+                });
+            });
+        },
+        async chatAgents(userId) {
+            const conn = tx.read();
+            const [agents, runners, settings, preferences, catalog] = await Promise.all([
+                deps.agents.list(),
+                deps.runners
+                    .list()
+                    .then((all) => all.filter((runner) => runner.status === 'online')),
+                deps.settings.settings(conn),
+                deps.settings.preferences(userId, conn),
+                deps.models.catalog(),
+            ]);
+            const replacement = await onlineFallback(conn, userId, catalog, settings);
+            const online = replacement?.availability.online
+                ? replacement.agent
+                : null;
+            return Promise.all(agents
+                .filter((agent) => deps.agents.mayInvoke(agent, userId))
+                .map(async (agent) => {
+                const availability = await availabilityFor(conn, agent, userId, catalog, undefined, runners);
+                return {
+                    id: agent.id,
+                    name: agent.name,
+                    description: agent.description,
+                    nameText: agent.nameText,
+                    descriptionText: agent.descriptionText,
+                    avatar: agent.avatar,
+                    type: agent.type,
+                    models: agent.type === 'online'
+                        ? chatModelChoices(onlineEntriesOrDefault(agent, catalog.defaultModel ?? null), catalog)
+                        : [],
+                    personal: agent.ownerUserId === userId && agent.access === 'ownerOnly',
+                    isSystemDefault: agent.id === settings.defaultAgentId,
+                    isMyDefault: agent.id === preferences.defaultAgentId,
+                    availability,
+                    fallbackAgentId: online &&
+                        agent.type === 'runner' &&
+                        availability.reason === 'noRunner'
+                        ? online.id
+                        : null,
+                };
+            }));
+        },
+        async copyAgent(userId, agentId, request) {
+            const source = await deps.agents.get(agentId);
+            if (!deps.agents.mayInvoke(source, userId))
+                throw notFound('Agent');
+            const name = request.name?.trim() || `${source.name} (copy)`;
+            if ([...name].length > 200)
+                throw invalid('name must be at most 200 characters.');
+            const copy = await deps.agents.create(userId, {
+                name,
+                description: source.description,
+                descriptionText: source.descriptionText,
+                avatar: source.avatar,
+                type: source.type,
+                modelEntries: source.modelEntries,
+                instructions: source.instructions,
+                actions: source.actions,
+                confirmChanges: source.confirmChanges,
+                access: 'ownerOnly',
+                userIds: [],
+                ownerUserId: userId,
+                runnerIds: source.runnerIds,
+                skillIds: source.skillIds,
+                maxConcurrentRuns: source.maxConcurrentRuns,
+                maxAttempts: source.maxAttempts,
+                toolPolicy: source.toolPolicy,
+            });
+            if (request.makeDefault)
+                await deps.settings.updatePreferences(userId, {
+                    defaultAgentId: copy.id,
+                });
+            return copy;
+        },
+    };
+    return service;
+}
+//# sourceMappingURL=conversation.service.js.map