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

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

@@ -1,3 +1,7 @@
+import { conversationAccess, createConversationShares, sharesRepo, } from './shares.js';
+import { runnerUIPage } from '../../online/agent/runner/projection.js';
+import { NativeMessages } from '../../online/agent/messages/projection.js';
+import { OnlineAgentConfigurator } from '../../online/agent/configuration.js';
 import { outputBlock, TERMINAL_RUN_STATUSES } from '@nocobase/agent-protocol';
 import { historicalPageContext, hasContent, renderPageContext, } from './page-context.js';
 import { nativeExecutionStatus, runnerBinding, } from '../../online/agent/persistence/state.js';
@@ -206,6 +210,12 @@ export function createConversationService(deps) {
         return workspace.resolve(conn, conversation, prepared);
     }
     const sources = createSources();
+    const shares = createConversationShares({
+        tx,
+        ids,
+        people: deps.people,
+        now,
+    });
     const links = createConversationLinks({
         tx,
         ids,
@@ -394,6 +404,9 @@ export function createConversationService(deps) {
             effort: typeof jsonObject(record.metadata).effort === 'string'
                 ? jsonObject(record.metadata).effort
                 : null,
+            wait: summary.mode === 'runner' && summary.run?.status === 'queued'
+                ? await deps.runs.queueWait(summary.run.id, record.runnerId)
+                : null,
             availability: await availabilityFor(conn, agent, record.userId),
             canFallback: Boolean(target),
             canRestore: !runnerBinding(record.metadata) &&
@@ -402,7 +415,48 @@ export function createConversationService(deps) {
     }
     async function detail(userId, id) {
         const conn = tx.read();
-        return detailOf(conn, await owned(conn, userId, id));
+        const { record, share } = await conversationAccess(conn, userId, id);
+        if (!share)
+            return detailOf(conn, record);
+        // Whitelist snapshot fields: no latest runner, project, execution, usage, wait or owner attention.
+        return {
+            id,
+            title: share.title,
+            titleSource: 'user',
+            category: 'chat',
+            showInChatList: false,
+            source: 'panel',
+            mode: record.mode,
+            agent: jsonObject(record.metadata).onlineAgent
+                ? {
+                    id: 'online',
+                    name: 'Online agent',
+                    nameText: null,
+                    avatar: null,
+                    archived: false,
+                }
+                : {
+                    ...agentRef(record.agentId, record.agentId ? await findAgent(conn, record.agentId) : null),
+                    avatar: null,
+                    archived: false,
+                },
+            fallbackFrom: null,
+            read: true,
+            lastMessageAt: share.snapshotAt,
+            archivedAt: null,
+            createdAt: record.createdAt,
+            updatedAt: share.updatedAt,
+            run: null,
+            lastSeq: Number(share.cutoffSeq),
+            links: [],
+            availability: { online: false, reason: null, onlineRunners: 0 },
+            canFallback: false,
+            canRestore: false,
+            snapshot: {
+                cutoffSeq: Number(share.cutoffSeq),
+                snapshotAt: share.snapshotAt,
+            },
+        };
     }
     // -------------------------------------------------------------------------------------------------------------------
     // Writing
@@ -742,6 +796,9 @@ export function createConversationService(deps) {
         const released = deps.attachments
             ? await deps.attachments.release(unit.conn, record.id)
             : async () => { };
+        await sharesRepo(unit.conn).deleteMany({
+            filter: { conversationId: record.id },
+        });
         await messagesRepo(unit.conn).deleteMany({
             filter: { conversationId: record.id },
         });
@@ -1100,6 +1157,35 @@ export function createConversationService(deps) {
                         messageId: `runner:${run.id}`,
                         revision: Number(answered.seq) + 1,
                     });
+                // Stop ends this turn; messages the Agent never acknowledged retain their identity in the next one.
+                // A queued withdrawal or system cancellation must not start more work.
+                if (run.status === 'cancelled' &&
+                    run.cancelRequestedAt !== null &&
+                    run.cancelledById === record.userId &&
+                    record.mode === 'runner' &&
+                    record.agentId === run.agentId) {
+                    const queued = await messagesRepo(unit.conn).findMany({
+                        filter: (f) => f.and([
+                            f.string('conversationId').eq(record.id),
+                            f.string('runId').eq(run.id),
+                            f.string('role').eq('user'),
+                            f.json('metadata').path(['queued']).eq(true),
+                        ]),
+                        sort: (sort) => sort.field('seq').asc(),
+                    });
+                    const pending = queued.filter((message) => {
+                        const metadata = metadataOf(message);
+                        return !metadata.pickedUp && !metadata.withdrawn;
+                    });
+                    if (pending.length) {
+                        await wake(unit, record, pending);
+                        for (const message of pending)
+                            changed(unit, record, {
+                                messageId: message.id,
+                                revision: Number(message.seq),
+                            });
+                    }
+                }
                 await attend(unit, record.id, run);
             },
         },
@@ -1328,6 +1414,81 @@ export function createConversationService(deps) {
     }
     const service = {
         binding,
+        shares,
+        async snapshotMessages(userId, id, query) {
+            const conn = tx.read();
+            const { record, share } = await conversationAccess(conn, userId, id);
+            if (!share)
+                return null;
+            const cutoff = Number(share.cutoffSeq);
+            let page;
+            if (record.mode === 'runner' || !jsonObject(record.metadata).onlineAgent)
+                page = await runnerUIPage(tx, id, cutoff, query, deps.basePath?.() ?? '', cutoff);
+            else {
+                const rows = await messagesRepo(conn).findMany({
+                    filter: (f) => f.and([
+                        f.string('conversationId').eq(id),
+                        f.number('seq').lte(cutoff),
+                        ...(query.ids
+                            ? [f.or(query.ids.map((key) => f.string('id').eq(key)))]
+                            : []),
+                        ...(query.before !== undefined
+                            ? [f.number('seq').lt(query.before)]
+                            : []),
+                        ...(query.after !== undefined
+                            ? [f.number('seq').gt(query.after)]
+                            : []),
+                    ]),
+                    sort: (s) => query.after !== undefined || query.ids
+                        ? s.field('seq').asc()
+                        : s.field('seq').desc(),
+                    limit: query.ids ? query.ids.length : query.limit + 1,
+                });
+                const hasMore = !query.ids && rows.length > query.limit;
+                const selected = rows.slice(0, query.ids ? rows.length : query.limit);
+                if (query.after === undefined && !query.ids)
+                    selected.reverse();
+                const native = new NativeMessages(new OnlineAgentConfigurator());
+                page = {
+                    items: selected.length
+                        ? await (deps.nativeHistory ??
+                            (async (values) => native.public(await native.validate(values))))(selected.map((row) => jsonObject(row.content).original))
+                        : [],
+                    lastSeq: cutoff,
+                    hasMore,
+                    ...(query.after !== undefined && hasMore && selected.length
+                        ? { nextAfter: Number(selected.at(-1).seq) }
+                        : {}),
+                };
+            }
+            for (const message of page.items) {
+                if (message.metadata) {
+                    delete message.metadata.queue;
+                    delete message.metadata.executionId;
+                    delete message.metadata.turnId;
+                }
+                // A shared transcript contains historical content; linked records are always resolved as this viewer.
+                if (message.metadata?.context) {
+                    const context = message.metadata.context;
+                    message.metadata.context = await deps.contextKinds.resolve(conn, userId, {
+                        route: '',
+                        items: context.items.map(({ kind, id }) => ({ kind, id })),
+                    });
+                }
+                const indexes = message.parts.flatMap((part, index) => part.type === 'data-turn' || part.type === 'data-phase'
+                    ? []
+                    : [index]);
+                if (message.metadata?.sourceRecords)
+                    message.metadata.sourceRecords = message.metadata.sourceRecords
+                        .filter((source) => indexes.includes(source.partIndex))
+                        .map((source) => ({
+                        ...source,
+                        partIndex: indexes.indexOf(source.partIndex),
+                    }));
+                message.parts = indexes.map((index) => message.parts[index]);
+            }
+            return page;
+        },
         contextKinds: deps.contextKinds,
         sources,
         ownedTitles,
@@ -1607,7 +1768,7 @@ export function createConversationService(deps) {
         sendRealtime: (userId, id, request, input) => sendMessage(userId, id, request, input),
         async withdraw(userId, id, messageId) {
             await tx.run(async (unit) => {
-                const record = await lockOwned(unit, userId, id, true);
+                let record = await owned(unit.conn, userId, id);
                 const message = await messagesRepo(unit.conn).findOne({
                     filter: { id: messageId, conversationId: id },
                 });
@@ -1616,25 +1777,44 @@ export function createConversationService(deps) {
                 const metadata = jsonObject(message.metadata);
                 if (metadata.withdrawn)
                     return;
-                // Taken back only while no runner has it: one conditional update, which a delivery racing it cannot both
-                // pass (`markDelivered` updates only an input not handled).
-                const taken = !metadata.queued ||
-                    metadata.pickedUp ||
-                    typeof metadata.inputId !== 'string' ||
-                    (await inputsRepo(unit.conn).updateMany({
-                        filter: (f) => f.and([
-                            f.string('id').eq(metadata.inputId),
-                            f.date('deliveredAt').empty(),
-                            f.date('handledAt').empty(),
-                        ]),
-                        values: { handledAt: now() },
-                    })).updatedCount !== 1;
-                if (taken)
-                    throw conversationConflict('messageTaken', 'The agent already has this message.');
+                if (!metadata.queued && message.runId) {
+                    // Match claim's run-before-conversation order. An initial turn has no queued-follow-up marker.
+                    // End only a still-unclaimed run, using the existing guarded queued withdrawal. If claim wins, the transaction rolls back and the running turn is kept.
+                    const run = await findRunRecord(unit.conn, message.runId);
+                    if (!run || run.status !== 'queued' || run.runnerId !== null)
+                        throw conversationConflict('messageTaken', 'The agent already has this message.');
+                    const ended = await deps.runs.withdrawQueued({
+                        subject: subjectOf(id),
+                        agentId: record.agentId,
+                        actorUserId: userId,
+                        byUserId: userId,
+                    }, unit);
+                    if (!ended.some((run) => run.id === message.runId))
+                        throw conversationConflict('messageTaken', 'The agent already has this message.');
+                    record = await lockOwned(unit, userId, id, true);
+                }
+                else {
+                    record = await lockOwned(unit, userId, id, true);
+                    // Taken back only while no runner has it: one conditional update, which a delivery racing it cannot both
+                    // pass (`markDelivered` updates only an input not handled).
+                    const taken = !metadata.queued ||
+                        metadata.pickedUp ||
+                        typeof metadata.inputId !== 'string' ||
+                        (await inputsRepo(unit.conn).updateMany({
+                            filter: (f) => f.and([
+                                f.string('id').eq(metadata.inputId),
+                                f.date('deliveredAt').empty(),
+                                f.date('handledAt').empty(),
+                            ]),
+                            values: { handledAt: now() },
+                        })).updatedCount !== 1;
+                    if (taken)
+                        throw conversationConflict('messageTaken', 'The agent already has this message.');
+                }
                 await messagesRepo(unit.conn).updateMany({
                     filter: { id: message.id },
                     values: {
-                        metadata: asJson({ ...metadata, withdrawn: true }),
+                        metadata: asJson({ ...metadata, queued: true, withdrawn: true }),
                         updatedAt: now(),
                     },
                 });