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

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

@@ -6,7 +6,7 @@ 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 { eventsAfter, hasSession, lastSummary, onlineEntryOf, 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 +76,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':
@@ -190,25 +194,81 @@ 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) {
+    /** 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 system = await systemDefault(conn, record.userId);
+        const target = await fallbackTarget(conn, record, catalog);
         return {
             ...summary,
-            availability: availabilityOf(agent, record.userId, deps.agents.mayInvoke, runners ?? (await deps.runners.list()), catalog, chosenModel(record)),
+            availability: await availabilityFor(conn, agent, record.userId, 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),
+            canFallback: Boolean(target),
+            canRestore: await canAnswer(conn, fallbackFrom, record.userId, catalog),
         };
     }
     async function detail(userId, id) {
@@ -232,9 +292,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);
@@ -251,6 +315,38 @@ export function createConversationService(deps) {
     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);
@@ -272,7 +368,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),
@@ -293,22 +389,27 @@ export function createConversationService(deps) {
                             : {}),
                     },
                 },
-            }, 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
-     * messages nobody answered go to the new agent.
+     * 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, 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: agent.type,
+                ...(agent.type === record.mode
+                    ? {}
+                    : { modelService: null, model: null }),
                 fallbackFromAgentId,
                 thread: Number(record.thread) + 1,
                 updatedAt: now(),
@@ -628,13 +729,51 @@ export function createConversationService(deps) {
             throw invalid('This application takes no files in chat.', {
                 field: 'attachmentIds',
             });
-        await owned(tx.read(), userId, id);
+        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) => {
-            const record = await lockOwned(unit, userId, id);
+            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({
@@ -742,11 +881,26 @@ 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)
+            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 agent = await pickAgent(unit.conn, userId, request.agentId);
+                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))))
@@ -765,7 +919,7 @@ export function createConversationService(deps) {
                         userId,
                         agentId: agent.id,
                         mode: agent.type,
-                        fallbackFromAgentId: null,
+                        fallbackFromAgentId: instead ? picked.id : null,
                         modelService: wanted?.modelService ?? null,
                         model: wanted?.model ?? null,
                         title,
@@ -784,7 +938,21 @@ export function createConversationService(deps) {
                         updatedAt: at,
                     },
                 });
-                changed(unit, (await findConversation(unit.conn, conversationId)));
+                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);
@@ -916,31 +1084,47 @@ export function createConversationService(deps) {
             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 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, {
-                    code: 'switchedToDefault',
-                    agentId: system.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 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,
@@ -1039,14 +1223,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,
@@ -1096,28 +1280,42 @@ export function createConversationService(deps) {
             const conn = tx.read();
             const [agents, runners, settings, preferences, catalog] = 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
+            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((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),
+                .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) {