@nocobase/app-plugin-agents 0.1.0-beta.1 → 0.1.0-beta.10

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

@@ -1,12 +1,13 @@
-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 { 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, } from '../../../shared/conversations.js';
+import { runnerTakesAgent } from '../../../shared/runners.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 { agentNamesOf } from '../agents/agent.store.js';
+import { eventsAfter, hasSession, lastSummary, openRunsOnEach, queuedRun, } from '../runs/index.js';
 import { findRunRecord, toRun } from '../runs/run.store.js';
 import { readAttachmentIds, storedAttachments, } from './attachments.js';
 import { availabilityOf, wakeable } from './availability.js';
@@ -76,6 +77,10 @@ function noticeText(notice, names) {
     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':
@@ -125,7 +130,7 @@ export function createConversationService(deps) {
             name: agent?.name ?? null,
             nameText: agent?.nameText ?? null,
             avatar: agent?.avatar ?? null,
-            archived: Boolean(agent?.archivedAt),
+            archived: agent ? agent.status !== 'enabled' : false,
         };
     }
     function runRef(runs) {
@@ -134,29 +139,7 @@ export function createConversationService(deps) {
             ? { 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;
+    async function summaries(conn, records) {
         const agents = new Map();
         for (const record of records)
             for (const id of [record.agentId, record.fallbackFromAgentId])
@@ -174,7 +157,6 @@ export function createConversationService(deps) {
             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,
@@ -190,25 +172,49 @@ export function createConversationService(deps) {
         const agent = await findAgent(conn, defaultAgentId);
         return wakeable(agent, userId, deps.agents.mayInvoke) ? agent : null;
     }
-    async function detailOf(conn, record, runners) {
-        const catalog = await deps.models.catalog();
-        const [summary] = await summaries(conn, [record], catalog.defaultModel);
+    /** Reads the same features and variable restrictions as claim, before any write transaction. */
+    async function availabilityFor(conn, agent, userId, runners) {
+        if (!wakeable(agent, userId, deps.agents.mayInvoke))
+            return availabilityOf(agent, userId, deps.agents.mayInvoke, 0);
+        const online = runners ??
+            (await deps.runners.list()).filter((runner) => runner.status === 'online');
+        const eligible = await deps.eligibility.runnersFor(conn, agent, {
+            actorUserId: userId,
+            runners: online,
+        });
+        return availabilityOf(agent, userId, deps.agents.mayInvoke, eligible.length, online.some((runner) => runnerTakesAgent(runner, agent)));
+    }
+    async function canAnswer(conn, agent, userId) {
+        if (!wakeable(agent, userId, deps.agents.mayInvoke))
+            return false;
+        return deps.eligibility.canClaim(conn, agent, { actorUserId: userId });
+    }
+    /**
+     * The agent `fallback` switches the conversation to: the system default when it can answer. Null while the
+     * conversation already uses another agent in place of its own.
+     */
+    async function fallbackTarget(conn, record) {
+        if (record.fallbackFromAgentId)
+            return null;
+        const system = await systemDefault(conn, record.userId);
+        if (system &&
+            system.id !== record.agentId &&
+            (await canAnswer(conn, system, record.userId)))
+            return system;
+        return null;
+    }
+    async function detailOf(conn, record) {
+        const [summary] = await summaries(conn, [record]);
         const agent = await findAgent(conn, record.agentId);
         const fallbackFrom = record.fallbackFromAgentId
             ? await findAgent(conn, record.fallbackFromAgentId)
             : null;
-        const system = await systemDefault(conn, record.userId);
+        const target = await fallbackTarget(conn, record);
         return {
             ...summary,
-            availability: availabilityOf(agent, record.userId, deps.agents.mayInvoke, runners ?? (await deps.runners.list()), catalog, chosenModel(record)),
-            models: record.mode === 'online' && agent
-                ? chatModelChoices(onlineEntriesOrDefault(agent, catalog.defaultModel ?? null), catalog)
-                : [],
-            canFallback: Boolean(system &&
-                !record.fallbackFromAgentId &&
-                system.id !== record.agentId &&
-                system.type === record.mode),
-            canRestore: wakeable(fallbackFrom, record.userId, deps.agents.mayInvoke),
+            availability: await availabilityFor(conn, agent, record.userId),
+            canFallback: Boolean(target),
+            canRestore: await canAnswer(conn, fallbackFrom, record.userId),
         };
     }
     async function detail(userId, id) {
@@ -232,9 +238,13 @@ export function createConversationService(deps) {
         return appended;
     }
     async function notice(unit, record, value, runId = null) {
-        const agentIds = value.code === 'switchedToDefault' || value.code === 'switchedBack'
+        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);
@@ -272,7 +282,7 @@ export function createConversationService(deps) {
         let result = null;
         for (const message of messages) {
             const files = storedAttachments(message.attachments);
-            const enqueued = await deps.runs.enqueue({
+            const enqueued = queuedRun(await deps.runs.enqueue({
                 agentId: agent.id,
                 subject: subjectOf(record.id),
                 threadScope: threadScopeOf(record),
@@ -287,28 +297,30 @@ export function createConversationService(deps) {
                         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);
+            }, 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 `agentId`: its queued work is withdrawn, the thread moves on (a new session), and the
+     * 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.
      */
-    async function rebind(unit, record, agentId, fallbackFromAgentId, value) {
+    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,
+                agentId: agent.id,
+                mode: 'runner',
+                modelService: null,
+                model: null,
                 fallbackFromAgentId,
                 thread: Number(record.thread) + 1,
                 updatedAt: now(),
@@ -365,13 +377,6 @@ export function createConversationService(deps) {
                     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,
@@ -394,7 +399,7 @@ export function createConversationService(deps) {
     // 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) {
+    async function conversationAssembly(conn, claim, conversation, ownerName, history, previousSummary) {
         const key = conversationKey(conversation.id);
         const added = await Promise.all(rules.map((source) => source(conn, {
             conversation: {
@@ -407,7 +412,6 @@ export function createConversationService(deps) {
             agent: claim.agent,
             ownerName,
             cli: claim.cli,
-            dialect: claim.dialect,
         })));
         return {
             subject: {
@@ -422,7 +426,6 @@ export function createConversationService(deps) {
                 key,
                 cli: claim.cli,
                 appName: claim.appName,
-                dialect: claim.dialect,
                 rules: added.flatMap((lines) => lines.rules ?? []),
                 sections: added.flatMap((lines) => lines.sections ?? []),
             }),
@@ -451,14 +454,11 @@ export function createConversationService(deps) {
             },
             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.
@@ -481,7 +481,7 @@ export function createConversationService(deps) {
                     title: sampleValue('This week'),
                     source: 'panel',
                     createdAt: claim.run.createdAt,
-                }, await nameOf(conn, claim.run.actorUserId ?? ''), [], null, null);
+                }, await nameOf(conn, claim.run.actorUserId ?? ''), [], null);
             },
         },
         context: {
@@ -542,7 +542,7 @@ export function createConversationService(deps) {
                         subjectId: record.id,
                     }, claim.run.id)
                     : null;
-                return conversationAssembly(conn, claim, { ...refOf(record), createdAt: record.createdAt }, ownerName, history, previousSummary, chosenModel(record) ?? null);
+                return conversationAssembly(conn, claim, { ...refOf(record), createdAt: record.createdAt }, ownerName, history, previousSummary);
             },
         },
         sink: {
@@ -740,17 +740,8 @@ export function createConversationService(deps) {
             };
         },
         async create(userId, request) {
-            const wanted = request.model ?? null;
-            // Read before the transaction, which a read on another connection would wait for.
-            const fallback = wanted
-                ? ((await deps.models.catalog()).defaultModel ?? null)
-                : null;
             const id = await tx.run(async (unit) => {
                 const agent = await pickAgent(unit.conn, userId, request.agentId);
-                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);
@@ -764,10 +755,10 @@ export function createConversationService(deps) {
                         id: conversationId,
                         userId,
                         agentId: agent.id,
-                        mode: agent.type,
+                        mode: 'runner',
                         fallbackFromAgentId: null,
-                        modelService: wanted?.modelService ?? null,
-                        model: wanted?.model ?? null,
+                        modelService: null,
+                        model: null,
                         title,
                         titleSource: title ? 'user' : 'auto',
                         category: 'chat',
@@ -791,10 +782,6 @@ export function createConversationService(deps) {
         },
         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 = {};
@@ -806,18 +793,6 @@ export function createConversationService(deps) {
                     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({
@@ -861,8 +836,51 @@ export function createConversationService(deps) {
                 hasMore = newest.length > limit;
                 rows = newest.slice(0, limit).reverse();
             }
+            const items = rows.map((row) => viewOf(row));
+            const consultationRuns = items.flatMap((item) => item.metadata?.notice?.code === 'consultation' &&
+                !item.metadata?.notice.agentId &&
+                item.metadata?.notice.runId
+                ? [item.metadata?.notice.runId]
+                : []);
+            const consultedRuns = consultationRuns.length
+                ? await conn.query
+                    .selectFrom('agRuns')
+                    .select(['id', 'agentId'])
+                    .where('id', 'in', consultationRuns)
+                    .execute()
+                : [];
+            const runAgents = new Map(consultedRuns.map((run) => [String(run.id), String(run.agentId)]));
+            const ids = items.flatMap((item) => item.metadata?.notice?.code === 'consultation'
+                ? [
+                    item.metadata?.notice.agentId ??
+                        (item.metadata?.notice.runId
+                            ? runAgents.get(item.metadata?.notice.runId)
+                            : undefined),
+                ].filter((id) => Boolean(id))
+                : []);
+            const names = await agentNamesOf(conn, ids);
             return {
-                items: rows.map((row) => viewOf(row)),
+                items: items.map((item) => {
+                    if (item.metadata?.notice?.code !== 'consultation')
+                        return item;
+                    const agentId = item.metadata?.notice.agentId ??
+                        (item.metadata?.notice.runId
+                            ? (runAgents.get(item.metadata?.notice.runId) ?? null)
+                            : null);
+                    const name = agentId ? names.get(agentId) : undefined;
+                    return {
+                        ...item,
+                        metadata: {
+                            ...item.metadata,
+                            notice: {
+                                ...item.metadata.notice,
+                                agentId,
+                                agentName: name ?? item.metadata.notice.agentName,
+                                identitySnapshot: name === undefined,
+                            },
+                        },
+                    };
+                }),
                 hasMore,
                 lastSeq: Number(current.lastSeq),
             };
@@ -916,31 +934,44 @@ export function createConversationService(deps) {
             return detail(userId, id);
         },
         async fallback(userId, id) {
+            const before = await owned(tx.read(), userId, id);
+            const target = await fallbackTarget(tx.read(), before);
             await tx.run(async (unit) => {
                 const record = await lockOwned(unit, userId, id);
-                const system = await systemDefault(unit.conn, userId);
-                if (!system ||
-                    record.fallbackFromAgentId ||
-                    system.id === record.agentId ||
-                    system.type !== record.mode)
-                    throw conversationConflict('noFallback', 'This conversation cannot switch to the default agent.');
-                await rebind(unit, record, system.id, record.agentId, {
+                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: 'switchedToDefault',
-                    agentId: system.id,
+                    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 tx.run(async (unit) => {
                 const record = await lockOwned(unit, userId, id);
-                const own = record.fallbackFromAgentId
-                    ? await findAgent(unit.conn, record.fallbackFromAgentId)
-                    : null;
-                if (!own || !wakeable(own, userId, deps.agents.mayInvoke))
+                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, own.id, null, {
+                await rebind(unit, record, current, null, {
                     code: 'switchedBack',
                     agentId: own.id,
                     fromAgentId: record.agentId,
@@ -994,41 +1025,6 @@ export function createConversationService(deps) {
                 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)
@@ -1039,14 +1035,14 @@ export function createConversationService(deps) {
             const agent = await findAgent(outer.conn, record.agentId);
             if (!wakeable(agent, record.userId, deps.agents.mayInvoke))
                 return null;
-            const enqueued = await deps.runs.enqueue({
+            const enqueued = queuedRun(await deps.runs.enqueue({
                 agentId: agent.id,
                 subject: subjectOf(record.id),
                 threadScope: threadScopeOf(record),
                 actorUserId: record.userId,
                 ownerUserId: record.userId,
                 input: news.input,
-            }, outer);
+            }, outer));
             return { id: enqueued.runId, outcome: enqueued.outcome };
         },
         lock: async (conn, id) => (await lockConversation(conn, id, now())) !== null,
@@ -1066,92 +1062,36 @@ export function createConversationService(deps) {
                 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([
+            const [agents, runners, settings, preferences] = await Promise.all([
                 deps.agents.list(),
-                deps.runners.list(),
+                deps.runners
+                    .list()
+                    .then((all) => all.filter((runner) => runner.status === 'online')),
                 deps.settings.settings(conn),
                 deps.settings.preferences(userId, conn),
-                deps.models.catalog(),
             ]);
-            return agents
-                .filter((agent) => deps.agents.mayInvoke(agent, userId))
-                .map((agent) => ({
-                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: availabilityOf(agent, userId, deps.agents.mayInvoke, runners, catalog),
+            return Promise.all(agents
+                // People talk to the agents discovered from runners; an application's own agents do work of its own.
+                .filter((agent) => agent.source === 'runner' && deps.agents.mayInvoke(agent, userId))
+                .map(async (agent) => {
+                const fitting = runners.filter((runner) => runnerTakesAgent(runner, agent));
+                return {
+                    id: agent.id,
+                    name: agent.name,
+                    description: agent.description,
+                    nameText: agent.nameText,
+                    descriptionText: agent.descriptionText,
+                    avatar: agent.avatar,
+                    isSystemDefault: agent.id === settings.defaultAgentId,
+                    isMyDefault: agent.id === preferences.defaultAgentId,
+                    availability: await availabilityFor(conn, agent, userId, runners),
+                    personalOnly: fitting.length > 0 &&
+                        fitting.every((runner) => runner.trust !== 'team'),
+                };
             }));
         },
-        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;
 }