@nocobase/app-plugin-agents 1.0.0-beta.29 → 2.0.0-beta.1

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

@@ -17,7 +17,7 @@ import { nativeExecutionStatus, runnerBinding, } from '../../online/agent/persis
  *   and bumps `thread`, so every switch starts a new session.
  */
 import { isDeepStrictEqual } from 'node:util';
-import { quotaForAgent } from '../../../shared/runners.js';
+import { quotaForAgent, chatEffortsFor, chatEffortCapabilities, } from '../../../shared/runners.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';
@@ -27,7 +27,7 @@ import { forbidden, conflict, invalid, notFound, ProtocolError, } from '../../ke
 import { asJson, jsonObject } from '../../kernel/values.js';
 import { findAgent } from '../agents/index.js';
 import { agentNamesOf } from '../agents/agent.store.js';
-import { eventsAfter, hasSession, lastSummary, openRunsOnEach, queuedRun, } from '../runs/index.js';
+import { eventsAfter, fitsActor, hasSession, lastSummary, openRunsOnEach, queuedRun, } from '../runs/index.js';
 import { eventsRepo, findRunRecord, inputsRepo, runsRepo, sessionsRepo, toRun, } from '../runs/run.store.js';
 import { readAttachmentIds, storedAttachments, } from './attachments.js';
 import { availabilityOf, wakeable } from './availability.js';
@@ -126,6 +126,7 @@ function refOf(record) {
         agentId: record.agentId,
         title: record.title,
         source: record.source,
+        projectId: record.projectId ?? null,
     };
 }
 function onlineExecution(record, open = [], active = false) {
@@ -196,6 +197,14 @@ export function createConversationService(deps) {
     /** 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 = [];
+    let workspace;
+    async function projectWorkspace(conn, conversation, prepared) {
+        if (!conversation.projectId)
+            return { dirs: [], scopes: [] };
+        if (!workspace)
+            throw invalid('Project workspaces are not available.');
+        return workspace.resolve(conn, conversation, prepared);
+    }
     const sources = createSources();
     const links = createConversationLinks({
         tx,
@@ -214,6 +223,20 @@ export function createConversationService(deps) {
             throw notFound('Conversation');
         return record;
     }
+    /** Titles for the current owner's conversations, read together for runner history. */
+    async function ownedTitles(conn, userId, ids) {
+        const uniqueIds = [...new Set(ids)];
+        if (uniqueIds.length === 0)
+            return new Map();
+        const records = await conversationsRepo(conn).findMany({
+            filter: (f) => f.and([
+                f.string('userId').eq(userId),
+                f.or(uniqueIds.map((id) => f.string('id').eq(id))),
+            ]),
+            select: (s) => s.fields('id', 'title'),
+        });
+        return new Map(records.map((record) => [String(record.id), record.title ?? '']));
+    }
     /** Locks the conversation if `userId` owns it; 404 otherwise. */
     async function lockOwned(unit, userId, id, allowOnline = false) {
         const record = (await lockConversation(unit.conn, id, now()));
@@ -241,6 +264,7 @@ export function createConversationService(deps) {
             : null;
     }
     async function summaries(conn, records) {
+        const linked = await links.summaries(conn, records);
         const agents = new Map();
         for (const record of records)
             for (const id of [
@@ -256,11 +280,13 @@ export function createConversationService(deps) {
         const machines = new Map((runnerIds.length ? await deps.runners.all(conn, runnerIds) : []).map((runner) => [runner.id, runner]));
         return Promise.all(records.map(async (record) => ({
             id: record.id,
+            links: linked.get(record.id) ?? [],
             title: record.title,
             titleSource: record.titleSource,
             category: record.category,
             showInChatList: record.showInChatList,
             source: record.source,
+            projectId: record.projectId ?? null,
             mode: record.mode,
             execution: onlineExecution(record, open, jsonObject(record.metadata).onlineAgent
                 ? await deps.nativeActive?.(record.id, jsonObject(jsonObject(jsonObject(record.metadata).onlineAgent).call).state === 'running')
@@ -312,6 +338,22 @@ export function createConversationService(deps) {
         const now = clock.now().getTime();
         return availabilityOf(agent, userId, deps.agents.mayInvoke, eligible.length, online.some((runner) => runnerTakesAgent(runner, agent, now)));
     }
+    async function effortOptions(conn, agent, userId) {
+        const eligible = await deps.eligibility.runnersFor(conn, agent, {
+            actorUserId: userId,
+        });
+        return chatEffortCapabilities(agent.modelEntries[0], eligible);
+    }
+    async function validateEffort(conn, agent, userId, selected) {
+        // Only an explicitly selected non-default value is a conversation preference.
+        const preference = selected && selected !== agent.modelEntries[0]?.effort ? selected : null;
+        if (preference === null)
+            return null;
+        const options = await effortOptions(conn, agent, userId);
+        if (options !== undefined && !options.includes(preference))
+            throw invalid('The reasoning effort is no longer supported. Select an available effort or restore the Agent default.', { reason: 'EFFORT_UNSUPPORTED', effort: preference, efforts: options });
+        return preference;
+    }
     async function canAnswer(conn, agent, userId) {
         if (!wakeable(agent, userId, deps.agents.mayInvoke))
             return false;
@@ -349,6 +391,9 @@ export function createConversationService(deps) {
         const target = await fallbackTarget(conn, record);
         return {
             ...summary,
+            effort: typeof jsonObject(record.metadata).effort === 'string'
+                ? jsonObject(record.metadata).effort
+                : null,
             availability: await availabilityFor(conn, agent, record.userId),
             canFallback: Boolean(target),
             canRestore: !runnerBinding(record.metadata) &&
@@ -493,6 +538,12 @@ export function createConversationService(deps) {
         const binding = runnerBinding(record.metadata);
         if (binding && !idleOnly)
             throw conflict('Start a new conversation to choose another agent.');
+        if (record.projectId && record.runnerId) {
+            const [runner] = await deps.runners.all(unit.conn, [record.runnerId]);
+            if (!runner ||
+                !fitsActor(runner, agent, record.userId, [], clock.now().getTime()))
+                throw conflict('This runner cannot run the selected Agent. Switch runner or start a new conversation.', { reason: 'boundRunnerIncompatible' });
+        }
         const withdrawn = idleOnly
             ? []
             : await deps.runs.withdrawQueued({ subject: subjectOf(record.id), byUserId: record.userId }, unit);
@@ -516,7 +567,7 @@ export function createConversationService(deps) {
                     }
                     : {}),
                 thread: Number(record.thread) + 1,
-                runnerId: null,
+                runnerId: record.projectId ? record.runnerId : null,
                 updatedAt: now(),
             },
         });
@@ -545,10 +596,11 @@ export function createConversationService(deps) {
     // 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) {
+    async function syncIn(unit, run, lockedRecord) {
         if (run.subject.kind !== CONVERSATION_SUBJECT)
             return;
-        const record = await lockConversation(unit.conn, run.subject.id, now());
+        const record = lockedRecord ??
+            (await lockConversation(unit.conn, run.subject.id, now()));
         if (!record || record.userId !== run.actorUserId)
             return;
         let after;
@@ -723,8 +775,9 @@ 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) {
+    async function conversationAssembly(conn, claim, conversation, ownerName, history, previousSummary, prepared) {
         const key = conversationKey(conversation.id);
+        const directories = await projectWorkspace(conn, conversation, prepared);
         const added = await Promise.all(rules.map((source) => source(conn, {
             conversation: {
                 id: conversation.id,
@@ -732,6 +785,7 @@ export function createConversationService(deps) {
                 agentId: conversation.agentId,
                 title: conversation.title,
                 source: conversation.source,
+                projectId: conversation.projectId ?? null,
             },
             agent: claim.agent,
             ownerName,
@@ -784,8 +838,7 @@ export function createConversationService(deps) {
                     source: conversation.source,
                 },
             },
-            dirs: [],
-            scopes: [],
+            ...directories,
         };
     }
     /**
@@ -862,7 +915,13 @@ export function createConversationService(deps) {
             },
         },
         context: {
-            async assemble(conn, claim) {
+            async prepare(run) {
+                const record = await findConversation(tx.read(), run.subject.id);
+                return record?.projectId
+                    ? workspace?.prepare(record.userId)
+                    : undefined;
+            },
+            async assemble(conn, claim, prepared) {
                 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)
@@ -916,16 +975,28 @@ export function createConversationService(deps) {
                 }
                 const previousSummary = fresh
                     ? await lastSummary(conn, {
-                        agentId: claim.agent.id,
+                        ...(record.projectId ? {} : { agentId: claim.agent.id }),
                         subjectKind: CONVERSATION_SUBJECT,
                         subjectId: record.id,
                     }, claim.run.id)
                     : null;
-                const assembly = await conversationAssembly(conn, claim, { ...refOf(record), createdAt: record.createdAt }, ownerName, history, previousSummary);
+                const assembly = await conversationAssembly(conn, claim, { ...refOf(record), createdAt: record.createdAt }, ownerName, history, previousSummary, prepared);
+                const preference = jsonObject(record.metadata).turnEffort ??
+                    jsonObject(record.metadata).effort;
+                const defaultEffort = claim.agent.modelEntries[0]?.effort;
+                const capabilities = chatEffortCapabilities(claim.agent.modelEntries[0], claim.runner ? [claim.runner] : []);
+                const effort = typeof preference === 'string'
+                    ? preference
+                    : capabilities === undefined
+                        ? null
+                        : defaultEffort && !capabilities.includes(defaultEffort)
+                            ? null
+                            : undefined;
+                const withEffort = effort === undefined ? assembly : { ...assembly, effort };
                 const config = runnerBinding(record.metadata)?.config;
                 return config
                     ? {
-                        ...assembly,
+                        ...withEffort,
                         system: [
                             assembly.system,
                             config.systemPrompt,
@@ -936,7 +1007,7 @@ export function createConversationService(deps) {
                             .filter(Boolean)
                             .join('\n\n'),
                     }
-                    : assembly;
+                    : withEffort;
             },
         },
         runnerPin: {
@@ -1076,6 +1147,8 @@ export function createConversationService(deps) {
         }
     }
     async function sendMessage(userId, id, request, realtime) {
+        if (request.effort !== undefined && !realtime)
+            throw invalid('Reasoning effort selection requires a Runner realtime message.', { reason: 'EFFORT_UNSUPPORTED' });
         if (request.agentId !== undefined && (!realtime || !request.agentId.trim()))
             throw invalid('Agent selection requires a Runner realtime message.');
         const content = request.content;
@@ -1112,6 +1185,7 @@ export function createConversationService(deps) {
         const sent = await measuredAdmission(async (unit) => {
             let record = await lockOwned(unit, userId, id, Boolean(realtime));
             let binding = runnerBinding(record.metadata);
+            let turnEffort = null;
             if (realtime) {
                 if (!binding)
                     throw invalid('This is not a Runner OnlineAgent conversation.');
@@ -1140,6 +1214,33 @@ export function createConversationService(deps) {
                     ((switching || !record.runnerId) &&
                         !(await canAnswer(unit.conn, agent, userId))))
                     throw conflict('This agent has no available execution environment.');
+                if (realtime.queue) {
+                    // Keep already received replies before this follow-up, under the admission's existing conversation lock.
+                    const working = open.find((run) => run.status !== 'queued');
+                    await syncIn(unit, working, record);
+                    record = (await findConversation(unit.conn, id));
+                }
+                turnEffort =
+                    typeof jsonObject(record.metadata).turnEffort === 'string'
+                        ? jsonObject(record.metadata).turnEffort
+                        : null;
+                if (!realtime.queue) {
+                    const effort = await validateEffort(unit.conn, agent, userId, request.effort);
+                    turnEffort = effort;
+                    if (effort !== (jsonObject(record.metadata).effort ?? null) ||
+                        turnEffort !== (jsonObject(record.metadata).turnEffort ?? null)) {
+                        const metadata = asJson({
+                            ...jsonObject(record.metadata),
+                            effort,
+                            turnEffort,
+                        });
+                        await conversationsRepo(unit.conn).updateMany({
+                            filter: { id },
+                            values: { metadata },
+                        });
+                        record = { ...record, metadata };
+                    }
+                }
                 if (switching) {
                     record = await rebind(unit, record, agent, null, {
                         code: 'switchedAgent',
@@ -1179,6 +1280,7 @@ export function createConversationService(deps) {
                 workContext: realtime?.workContext ?? context,
                 metadata: {
                     ...(request.clientId ? { clientId: request.clientId } : {}),
+                    ...(turnEffort ? { effort: turnEffort } : {}),
                     ...(realtime?.queue ? { queued: true } : {}),
                 },
             });
@@ -1228,6 +1330,7 @@ export function createConversationService(deps) {
         binding,
         contextKinds: deps.contextKinds,
         sources,
+        ownedTitles,
         async list(userId, query) {
             const conn = tx.read();
             const limit = limitOf(query.pageSize, CONVERSATION_PAGE_DEFAULT, CONVERSATION_PAGE_MAX);
@@ -1310,6 +1413,9 @@ export function createConversationService(deps) {
             };
         },
         async create(userId, request, runnerConfig) {
+            const prepared = request.projectId
+                ? await workspace?.prepare(userId)
+                : undefined;
             const id = await tx.run(async (unit) => {
                 const agent = await pickAgent(unit.conn, userId, request.agentId);
                 if (runnerConfig &&
@@ -1317,6 +1423,7 @@ export function createConversationService(deps) {
                     throw invalid('Select a callable Runner agent.');
                 if (runnerConfig && !(await canAnswer(unit.conn, agent, userId)))
                     throw conflict('This agent has no available execution environment.');
+                const effort = await validateEffort(unit.conn, agent, userId, request.effort);
                 const title = request.title === undefined
                     ? null
                     : titleFor(request.title, CONVERSATION_TITLE_MAX);
@@ -1325,17 +1432,27 @@ export function createConversationService(deps) {
                 if (source !== 'panel' && !sources.has(source))
                     throw invalid(`${source} is not a source conversations start from.`);
                 const conversationId = ids.next();
+                if (request.projectId && agent.source !== 'runner')
+                    throw invalid('Only Runner conversations can select a project.');
+                await projectWorkspace(unit.conn, {
+                    id: conversationId,
+                    userId,
+                    agentId: agent.id,
+                    title,
+                    source,
+                    projectId: request.projectId,
+                }, prepared);
                 await conversationsRepo(unit.conn).createOne({
                     values: {
                         id: conversationId,
-                        ...(runnerConfig
-                            ? {
-                                metadata: asJson({
-                                    runnerOnlineAgent: { version: 1, config: runnerConfig },
-                                }),
-                            }
-                            : {}),
+                        metadata: asJson({
+                            effort,
+                            ...(runnerConfig
+                                ? { runnerOnlineAgent: { version: 1, config: runnerConfig } }
+                                : {}),
+                        }),
                         userId,
+                        projectId: request.projectId ?? null,
                         agentId: agent.id,
                         mode: 'runner',
                         fallbackFromAgentId: null,
@@ -1365,9 +1482,24 @@ export function createConversationService(deps) {
         },
         get: detail,
         async update(userId, id, patch) {
+            const prepared = patch.projectId
+                ? await workspace?.prepare(userId)
+                : undefined;
             await tx.run(async (unit) => {
                 const record = await lockOwned(unit, userId, id, true);
                 const values = {};
+                if (patch.projectId !== undefined &&
+                    patch.projectId !== (record.projectId ?? null)) {
+                    if (Number(record.lastSeq) > 0 &&
+                        (await messagesRepo(unit.conn).findOne({
+                            filter: { conversationId: id, role: 'user' },
+                        })))
+                        throw conflict('Start a new conversation to choose another project.');
+                    if (record.mode !== 'runner')
+                        throw invalid('Only Runner conversations can select a project.');
+                    await projectWorkspace(unit.conn, { ...refOf(record), projectId: patch.projectId }, prepared);
+                    values.projectId = patch.projectId;
+                }
                 if (patch.title !== undefined) {
                     values.title = titleFor(patch.title, CONVERSATION_TITLE_MAX);
                     values.titleSource = 'user';
@@ -1567,7 +1699,9 @@ export function createConversationService(deps) {
                     filter: { id },
                     values,
                 });
-                changed(unit, record);
+                changed(unit, record, values.seenSeq === undefined
+                    ? undefined
+                    : { seenSeq: values.seenSeq });
             });
             return detail(userId, id);
         },
@@ -1959,6 +2093,17 @@ export function createConversationService(deps) {
             return { id: enqueued.runId, outcome: enqueued.outcome };
         },
         lock: async (conn, id) => (await lockConversation(conn, id, now())) !== null,
+        workspace: {
+            provide(provider) {
+                if (workspace)
+                    throw new Error('A conversation workspace provider is already registered.');
+                workspace = provider;
+                return () => {
+                    if (workspace === provider)
+                        workspace = undefined;
+                };
+            },
+        },
         rules: {
             provide(source) {
                 rules.push(source);
@@ -2001,7 +2146,14 @@ export function createConversationService(deps) {
                 .filter((agent) => agent.source === 'runner' && deps.agents.mayInvoke(agent, userId))
                 .map(async (agent) => {
                 const fitting = runners.filter((runner) => runnerTakesAgent(runner, agent, now));
+                const eligible = await deps.eligibility.runnersFor(conn, agent, {
+                    actorUserId: userId,
+                    runners,
+                    variableState: variableStates?.get(agent.id),
+                });
                 return {
+                    efforts: chatEffortsFor(agent.modelEntries[0], eligible),
+                    effort: agent.modelEntries[0]?.effort ?? null,
                     id: agent.id,
                     name: agent.name,
                     description: agent.description,
@@ -2010,7 +2162,7 @@ export function createConversationService(deps) {
                     avatar: agent.avatar,
                     isSystemDefault: agent.id === settings.defaultAgentId,
                     isMyDefault: agent.id === preferences.defaultAgentId,
-                    availability: await availabilityFor(conn, agent, userId, runners, variableStates?.get(agent.id)),
+                    availability: availabilityOf(agent, userId, deps.agents.mayInvoke, eligible.length, fitting.length > 0),
                     quota: quotaForAgent(runners, agent, userId, now),
                     runnerNames: fitting
                         .filter((runner) => runner.trust === 'team' || runner.ownerUserId === userId)