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

package/dist/client/chat/controller.js

@@ -31,9 +31,7 @@ export class ChatController {
     histories = new Map();
     loads = new Map();
     refreshAgain = new Set();
-    resumed = new Set();
-    resuming = new Map();
-    recoveryErrors = new Map();
+    recoveries = new Map();
     admissions = new Map();
     watches = new Map();
     messageVersions = new Map();
@@ -47,6 +45,7 @@ export class ChatController {
     disposed = false;
     generation = 0;
     detailVersions = new Map();
+    receiptVersions = new Map();
     commandVersions = new Map();
     constructor(api) {
         this.api = api;
@@ -69,7 +68,22 @@ export class ChatController {
                     const admission = this.admissions.get(id);
                     if (!this.disposed && admission?.clientId === clientId)
                         admission.gate.resolve();
-                }, (options) => this.resendAccepted(id, options)),
+                }, (options) => this.resendAccepted(id, options), () => {
+                    const active = this.lifetime(), recovery = this.recoveries.get(id);
+                    return (available) => {
+                        if (!active() ||
+                            this.chats.get(id) !== chat ||
+                            !recovery ||
+                            this.recoveries.get(id) !== recovery)
+                            return;
+                        recovery.phase = available ? 'live' : 'history';
+                        recovery.error = undefined;
+                        // Reads started before reconnection must not replace its replay or revive old errors.
+                        this.nextDetailVersion(id);
+                        this.invalidateHistoryReads(id);
+                        this.publish();
+                    };
+                }),
                 onFinish: () => {
                     if (!this.disposed && this.chats.get(id) === chat)
                         this.scheduleRefresh(id);
@@ -180,15 +194,18 @@ export class ChatController {
         this.publish();
     }
     historyLifetime(id) {
-        const active = this.lifetime(), epoch = this.historyEpochs.get(id) ?? 0;
-        return () => active() && (this.historyEpochs.get(id) ?? 0) === epoch;
+        const active = this.lifetime(), epoch = this.historyEpochs.get(id) ?? 0, command = this.commandVersions.get(id);
+        return () => active() &&
+            (this.historyEpochs.get(id) ?? 0) === epoch &&
+            this.commandVersions.get(id) === command;
     }
-    invalidateHistoryReads(id) {
+    invalidateHistoryReads(id, discardDeferred = false) {
         this.historyEpochs.set(id, (this.historyEpochs.get(id) ?? 0) + 1);
         this.loads.delete(id);
         this.refreshAgain.delete(id);
         this.revisionQueue.delete(id);
-        this.deferredReads.delete(id);
+        if (discardDeferred)
+            this.deferredReads.delete(id);
         for (const key of this.messageVersions.keys())
             if (key.startsWith(`${id}:`))
                 this.messageVersions.delete(key);
@@ -221,8 +238,8 @@ export class ChatController {
         if (previous?.executionId === event.executionId ||
             (previous && previous.lastSeq > event.lastSeq))
             return false;
-        this.invalidateHistoryReads(id);
-        this.resuming.delete(id);
+        this.invalidateHistoryReads(id, true);
+        this.recoveries.delete(id);
         this.replacements.set(id, event);
         this.dispatch(id, { type: 'replaceHistory', ...event });
         this.historyMeta(id).loadedThrough = Math.max(this.historyMeta(id).loadedThrough, event.lastSeq);
@@ -664,14 +681,16 @@ export class ChatController {
     async sendInput(id, input) {
         if (this.disposed)
             throw new CancelledError({ silent: true });
-        const chat = this.chat(id);
+        let chat = this.chat(id);
         if (chat.status === 'submitted' || chat.status === 'streaming')
             throw new Error('This conversation is already receiving a response.');
         if (this.resendRequests.has(id))
             throw new Error('This conversation is busy.');
         const admitted = deferred();
         this.admissions.set(id, { clientId: input.clientId, gate: admitted });
-        this.recoveryErrors.delete(id);
+        this.recoveries.delete(id);
+        // A new turn owns its callbacks, including when the previous transport finishes late.
+        chat = this.renewChat(id, chat.messages);
         const active = this.lifetime();
         const sending = chat.sendMessage({
             id: input.clientId,
@@ -697,6 +716,7 @@ export class ChatController {
         }, {
             body: {
                 ...(input.agentId ? { agentId: input.agentId } : {}),
+                ...(input.effort !== undefined ? { effort: input.effort } : {}),
                 ...(input.context ? { context: input.context } : {}),
                 ...(input.attachmentIds?.length
                     ? { attachmentIds: input.attachmentIds }
@@ -727,42 +747,82 @@ export class ChatController {
     }
     state(id) {
         const chat = this.chats.get(id);
+        const recovery = this.recoveries.get(id);
+        const recovering = recovery?.phase === 'recovering';
+        const error = recovering ? undefined : (chat?.error ?? recovery?.error);
         return chat
             ? {
                 status: chat.status,
-                error: chat.error ?? this.recoveryErrors.get(id),
+                error,
+                recovery: recovering
+                    ? 'recovering'
+                    : error
+                        ? 'interrupted'
+                        : recovery?.phase === 'history'
+                            ? 'history'
+                            : undefined,
             }
             : undefined;
     }
+    recoveryKey(id, detail) {
+        return (detail.run?.id ??
+            detail.execution?.messageId ??
+            (detail.execution?.status === 'running'
+                ? this.recoveries.get(id)?.key
+                : undefined) ??
+            [...this.chat(id).messages].reverse().find((m) => m.role === 'user')
+                ?.id ??
+            '');
+    }
     receive(id, known) {
-        if (this.disposed || this.resumed.has(id))
+        if (this.disposed)
             return;
         const detail = known ??
             agentsQueryClient().getQueryData(chatKeys.conversation(id));
-        if (!detail?.execution)
-            return;
-        this.resumed.add(id);
-        if (detail?.execution?.status === 'idle' ||
-            detail?.execution?.waitingApproval)
+        if (!detail ||
+            this.recoveries.get(id)?.key === this.recoveryKey(id, detail))
             return;
-        void this.resume(id);
+        void this.resume(id, detail);
     }
-    async resume(id) {
+    async resume(id, known) {
         if (this.disposed)
             return;
-        const pending = this.resuming.get(id);
-        if (pending)
-            return pending;
+        const detail = known ??
+            agentsQueryClient().getQueryData(chatKeys.conversation(id));
+        if (!detail)
+            return;
+        if (!chatIsRunning(detail) || detail.execution?.waitingApproval) {
+            const chat = this.chats.get(id);
+            if (chat?.status !== 'submitted' && chat?.status !== 'streaming')
+                await this.loadHistory(id);
+            return;
+        }
+        const key = this.recoveryKey(id, detail);
+        const pending = this.recoveries.get(id);
         let chat = this.chat(id);
-        if (chat.status === 'submitted' || chat.status === 'streaming')
+        if (chat.status === 'submitted' || chat.status === 'streaming') {
+            if (!pending || pending.key !== key)
+                this.recoveries.set(id, { key, phase: 'live' });
             return;
+        }
+        if (pending?.key === key) {
+            if (pending.task)
+                return pending.task;
+            if (pending.phase === 'history')
+                return;
+        }
         const active = this.lifetime();
         const replacement = this.replacements.get(id);
-        const canResume = () => active() &&
+        const command = this.commandVersions.get(id);
+        const recovery = { key, phase: 'recovering' };
+        this.recoveries.set(id, recovery);
+        this.publish();
+        const current = () => active() &&
+            this.commandVersions.get(id) === command &&
+            this.recoveries.get(id) === recovery &&
             this.replacements.get(id) === replacement &&
-            this.chats.get(id) === chat &&
-            chat.status !== 'submitted' &&
-            chat.status !== 'streaming';
+            this.chats.get(id) === chat;
+        const canResume = () => current() && chat.status !== 'submitted' && chat.status !== 'streaming';
         const task = (async () => {
             let interrupted;
             try {
@@ -770,6 +830,8 @@ export class ChatController {
                 // A new input can begin while the recovery snapshot is still being read.
                 if (!canResume())
                     return;
+                if (this.history(id).error)
+                    throw this.history(id).error;
                 if (chat.error) {
                     const previous = chat;
                     interrupted = [...previous.messages]
@@ -790,36 +852,57 @@ export class ChatController {
                     if (!active())
                         return;
                 }
-                this.recoveryErrors.delete(id);
                 chat.clearError();
                 const response = [...chat.messages]
                     .reverse()
                     .find((message) => message.role === 'assistant');
-                if (response)
+                if (response &&
+                    (response === interrupted ||
+                        !key ||
+                        response.metadata?.executionId === key ||
+                        response.id === detail.execution?.messageId)) {
+                    interrupted ??= response;
                     chat.messages = mergeUIMessages(chat.messages, [], response.id);
+                }
                 await chat.resumeStream();
-                if (active())
+                if (current()) {
+                    if (chat.error) {
+                        recovery.phase = 'interrupted';
+                        recovery.error = chat.error;
+                    }
                     await this.refresh(id);
+                }
             }
             catch (error) {
-                if (canResume())
-                    this.recoveryErrors.set(id, error instanceof Error
-                        ? error
-                        : new Error('Stream recovery failed.'));
+                if (current()) {
+                    if (chat.error) {
+                        recovery.phase = 'interrupted';
+                        recovery.error = chat.error;
+                    }
+                    else {
+                        // A failed history read is not evidence that the transport failed.
+                        this.historyMeta(id).error = error;
+                        if (recovery.phase === 'recovering')
+                            recovery.phase = 'live';
+                    }
+                }
             }
             finally {
-                if (active()) {
+                if (current()) {
                     const display = interrupted;
                     if (display &&
                         canResume() &&
                         !chat.messages.some((message) => message.id === display.id))
                         chat.messages = mergeUIMessages(chat.messages, [display]);
-                    this.resuming.delete(id);
+                    recovery.task = undefined;
+                    if (recovery.phase === 'recovering' &&
+                        (chat.status === 'submitted' || chat.status === 'streaming'))
+                        recovery.phase = 'live';
                     this.publish();
                 }
             }
         })();
-        this.resuming.set(id, task);
+        recovery.task = task;
         return task;
     }
     async approve(id, input) {
@@ -867,7 +950,13 @@ export class ChatController {
     async refresh(id) {
         if (this.disposed)
             return;
-        const active = this.lifetime(), ordered = this.detailRequest(id);
+        const lifetime = this.lifetime(), commandVersion = this.commandVersions.get(id), active = () => lifetime() && this.commandVersions.get(id) === commandVersion, ordered = this.detailRequest(id);
+        const submittedOwner = this.chat(id);
+        const submittedInput = submittedOwner.status === 'submitted' && !this.admissions.has(id)
+            ? [...submittedOwner.messages]
+                .reverse()
+                .find((message) => message.role === 'user' && message.metadata?.seq !== undefined)
+            : undefined;
         const detail = await this.api.conversation(id);
         if (!active())
             return;
@@ -878,7 +967,7 @@ export class ChatController {
         // A newer detail query must not discard this refresh's message catch-up.
         // loadHistory coalesces overlapping reads independently of detail ordering.
         await this.loadHistory(id, false, true);
-        if (!active() || !ordered())
+        if (!active())
             return;
         const history = this.history(id);
         if (history.error)
@@ -903,14 +992,29 @@ export class ChatController {
         if (!active() || !ordered())
             return;
         const owner = this.chat(id), receiving = owner.messages.at(-1);
-        if (owner.status === 'streaming' &&
-            receiving?.role === 'assistant' &&
-            (detail.execution?.status === 'idle' ||
-                detail.execution?.waitingApproval) &&
-            saved.some((message) => message.id === receiving.id &&
+        const lastUser = [...owner.messages]
+            .reverse()
+            .find((message) => message.role === 'user');
+        const executionId = submittedInput?.metadata?.executionId ?? this.recoveries.get(id)?.key;
+        const submittedTerminal = owner === submittedOwner &&
+            owner.status === 'submitted' &&
+            submittedInput &&
+            lastUser?.id === submittedInput.id &&
+            detail.execution?.status === 'idle' &&
+            [...saved, ...owner.messages].some((message) => message.role !== 'user' &&
                 message.metadata?.seq !== undefined &&
-                message.metadata?.executionId === receiving.metadata?.executionId &&
-                message.metadata.revision >= (detail.execution?.revision ?? 0))) {
+                message.metadata.seq > submittedInput.metadata.seq &&
+                ((executionId && message.metadata.executionId === executionId) ||
+                    message.id === detail.execution?.messageId));
+        if (submittedTerminal ||
+            (owner.status === 'streaming' &&
+                receiving?.role === 'assistant' &&
+                (detail.execution?.status === 'idle' ||
+                    detail.execution?.waitingApproval) &&
+                saved.some((message) => message.id === receiving.id &&
+                    message.metadata?.seq !== undefined &&
+                    message.metadata?.executionId === receiving.metadata?.executionId &&
+                    message.metadata.revision >= (detail.execution?.revision ?? 0)))) {
             // Durable completion can release a lost subscriber; this never calls business Stop.
             await owner.stop();
             if (!active() || !ordered())
@@ -919,20 +1023,13 @@ export class ChatController {
         }
         if (!active() || !ordered())
             return;
-        this.remember(detail);
+        this.remember(detail, false);
         const chat = this.chat(id);
         if (detail.execution?.status === 'idle') {
-            this.recoveryErrors.delete(id);
-            if (chat.error &&
-                saved.some((message) => message.id === chat.messages.at(-1)?.id &&
-                    message.metadata?.seq !== undefined))
+            this.recoveries.delete(id);
+            if (chat.error)
                 this.renewChat(id, chat.messages);
         }
-        else if (detail.execution?.status === 'running' &&
-            !detail.execution.waitingApproval &&
-            chat.status !== 'submitted' &&
-            chat.status !== 'streaming')
-            this.recoveryErrors.set(id, new Error('Execution remains active; reconcile saved history or resume its stream.'));
         this.publish();
     }
     scheduleRefresh(id) {
@@ -945,14 +1042,16 @@ export class ChatController {
                 void this.refresh(id).catch(() => { });
         });
     }
-    observeDetail(detail) {
+    observeDetail(detail, refresh = true) {
         if (detail.execution?.status === 'running')
             this.receive(detail.id, detail);
         if (!chatIsRunning(detail)) {
-            if (this.chats.get(detail.id)?.status === 'streaming')
+            if (refresh &&
+                (this.chats.get(detail.id)?.status === 'streaming' ||
+                    this.chats.get(detail.id)?.status === 'submitted'))
                 this.scheduleRefresh(detail.id);
             this.stopRequests.delete(detail.id);
-            this.recoveryErrors.delete(detail.id);
+            this.recoveries.delete(detail.id);
             this.publish();
         }
     }
@@ -987,16 +1086,38 @@ export class ChatController {
         const active = this.lifetime(), version = this.nextDetailVersion(id);
         return () => active() && this.detailVersions.get(id) === version;
     }
-    remember(detail) {
+    remember(detail, refresh = true) {
         this.nextDetailVersion(detail.id);
-        this.observeDetail(detail);
+        this.observeDetail(detail, refresh);
         agentsQueryClient().setQueryData(chatKeys.conversation(detail.id), detail);
         void agentsQueryClient().invalidateQueries({ queryKey: chatKeys.lists });
     }
+    async markRead(id) {
+        const active = this.lifetime(), commandVersion = this.commandVersions.get(id), receiptVersion = (this.receiptVersions.get(id) ?? 0) + 1;
+        // Detail reads must not suppress the read transition needed by a viewed conversation.
+        this.receiptVersions.set(id, receiptVersion);
+        this.nextDetailVersion(id);
+        const detail = await this.api.markRead(id);
+        if (active() &&
+            this.commandVersions.get(id) === commandVersion &&
+            this.receiptVersions.get(id) === receiptVersion) {
+            // Read receipts do not change execution or invalidate pending history.
+            this.nextDetailVersion(id);
+            agentsQueryClient().setQueryData(chatKeys.conversation(id), detail);
+            void agentsQueryClient().invalidateQueries({ queryKey: chatKeys.lists });
+        }
+        return detail;
+    }
     async command(id, request, detail) {
         const active = this.lifetime(), version = (this.commandVersions.get(id) ?? 0) + 1;
         this.commandVersions.set(id, version);
         this.nextDetailVersion(id);
+        this.invalidateHistoryReads(id);
+        const recovery = this.recoveries.get(id);
+        if (recovery?.phase === 'history')
+            this.recoveries.set(id, { key: recovery.key, phase: 'history' });
+        else
+            this.recoveries.delete(id);
         await agentsQueryClient().cancelQueries({
             queryKey: chatKeys.conversation(id),
             exact: true,
@@ -1047,10 +1168,10 @@ export class ChatController {
         this.loads.clear();
         this.refreshAgain.clear();
         this.commandVersions.clear();
+        this.receiptVersions.clear();
         this.stopRequests.clear();
         this.approvalRequests.clear();
-        this.resuming.clear();
-        this.resumed.clear();
+        this.recoveries.clear();
         this.submissions.invalidate();
         agentsQueryClient().removeQueries({ queryKey: chatKeys.all });
     }