agent-tower 0.7.2-beta.7 → 0.7.2

package/dist/services/session-manager.js

@@ -4,7 +4,7 @@ import { getProviderById, ExecutionEnv, isPreChildProcessFailure, markPreChildPr
 import { filterAgentSubprocessExternalEnv } from '../executors/execution-env.js';
 import { sessionMsgStoreManager, createUserMessage, addNormalizedEntry, } from '../output/index.js';
 import { execGit } from '../git/git-cli.js';
-import { getCommitMessageService } from '../core/container.js';
+import { getCommitMessageService, getTranslationService } from '../core/container.js';
 import { TeamReconcilerService } from './team-reconciler.service.js';
 import { acquireTeamMemberAdmission } from './team-member-admission-barrier.js';
 import { NotFoundError, ServiceError, ValidationError } from '../errors.js';
@@ -106,6 +106,8 @@ function isAgentProgressPatch(patch) {
         return false;
     }
     return patch.some((op) => {
+        if (op && typeof op === 'object' && 'path' in op && /\/metadata$/.test(String(op.path)) && 'value' in op && op.value && typeof op.value === 'object' && Object.keys(op.value).every(key => key === 'textBlock'))
+            return false;
         const value = op?.value;
         if (!value || typeof value !== 'object') {
             // 非整条 entry 写入（如对 /entries/N/content 的流式更新）视为 agent 进展。
@@ -130,6 +132,10 @@ function hasCompletePersistedSnapshot(session) {
 export class SessionManager {
     eventBus;
     executionPermissions;
+    deliveryService;
+    setMessageDeliveryService(service) { this.deliveryService = service; }
+    resumeConversationQueue(sessionId) { this.kickConversationQueue(sessionId); }
+    translationBoundaryPending = new Set();
     snapshotFlushTimers = new Map();
     snapshotFlushChains = new Map();
     sessionPersistenceWriterChain = Promise.resolve();
@@ -172,6 +178,7 @@ export class SessionManager {
     /** Durable conversation turns are consumed one at a time per Session. */
     conversationQueueWorkers = new Map();
     conversationQueueStopping = false;
+    pendingConversationQueueKicks = new Set();
     artifactService = new AgentArtifactService();
     static SNAPSHOT_CHECKPOINT_MS = 15_000;
     static HEARTBEAT_THROTTLE_MS = 30_000;
@@ -350,22 +357,27 @@ export class SessionManager {
     }
     /** Recover turns left in RUNNING state by an interrupted server process. */
     async startConversationQueue() {
-        this.conversationQueueStopping = false;
+        this.conversationQueueStopping = true;
         await prisma.conversationTurn.updateMany({
-            where: { status: CONVERSATION_TURN_RUNNING },
+            where: { status: CONVERSATION_TURN_RUNNING, deliveryId: null },
             data: {
                 status: CONVERSATION_TURN_QUEUED,
                 startedAt: null,
             },
         });
+        const interruptedDeliveries = await prisma.conversationTurn.findMany({ where: { status: CONVERSATION_TURN_RUNNING, deliveryId: { not: null } }, include: { delivery: true } });
+        for (const turn of interruptedDeliveries)
+            await prisma.conversationTurn.update({ where: { id: turn.id }, data: { status: turn.delivery?.state === 'SENT' ? CONVERSATION_TURN_FAILED : turn.delivery?.state === 'ACCEPTED' ? CONVERSATION_TURN_QUEUED : 'PAUSED', lastError: 'INTERRUPTED_EXECUTION' } });
         const pending = await prisma.conversationTurn.findMany({
             where: { status: CONVERSATION_TURN_QUEUED },
             select: { sessionId: true },
             distinct: ['sessionId'],
         });
-        for (const turn of pending) {
-            this.kickConversationQueue(turn.sessionId);
-        }
+        const sessions = new Set([...pending.map(turn => turn.sessionId), ...this.pendingConversationQueueKicks]);
+        this.pendingConversationQueueKicks.clear();
+        this.conversationQueueStopping = false;
+        for (const sessionId of sessions)
+            this.kickConversationQueue(sessionId);
     }
     /** Stop scheduling new work during the Fastify shutdown phase. */
     stopConversationQueue() {
@@ -468,7 +480,20 @@ export class SessionManager {
         authorizeDelivery();
         await this.runtimeCoordinator.resolvePermission(sessionId, requestId, optionId, authorizeDelivery);
     }
-    async create(workspaceId, agentType, prompt, variant = 'DEFAULT', providerId) {
+    async create(workspaceId, agentType, prompt, variant = 'DEFAULT', providerId, input) {
+        const fingerprint = createHash('sha256').update(JSON.stringify([workspaceId, agentType, prompt, variant, providerId ?? null, input?.attachmentIds ?? [], !!input?.retryTask])).digest('hex');
+        if (input?.clientSubmissionId) {
+            const existing = await prisma.session.findUnique({ where: { creationSubmissionId: input.clientSubmissionId } });
+            if (existing) {
+                if (existing.workspaceId !== workspaceId || existing.creationFingerprint !== fingerprint)
+                    throw new ServiceError('Submission identity conflict', 'DELIVERY_CONFLICT', 409);
+                const workspace = await prisma.workspace.findUnique({ where: { id: workspaceId }, include: { task: true } });
+                if (!workspace)
+                    throw new NotFoundError('Workspace', workspaceId);
+                ensureTaskNotDeleted(workspace.task);
+                return existing;
+            }
+        }
         const workspace = await prisma.workspace.findUnique({
             where: { id: workspaceId },
             include: { task: true },
@@ -491,6 +516,9 @@ export class SessionManager {
         }
         return prisma.session.create({
             data: {
+                creationSubmissionId: input?.clientSubmissionId,
+                creationFingerprint: fingerprint,
+                inputIntent: JSON.stringify({ attachmentIds: input?.attachmentIds ?? [], retryTask: !!input?.retryTask }),
                 workspaceId,
                 context: SessionContext.WORKSPACE,
                 agentType,
@@ -500,9 +528,13 @@ export class SessionManager {
                 prompt,
                 status: SessionStatus.PENDING,
             },
+        }).catch(async (error) => {
+            if (error.code === 'P2002' && input?.clientSubmissionId)
+                return this.create(workspaceId, agentType, prompt, variant, providerId, input);
+            throw error;
         });
     }
-    async start(id) {
+    async start(id, input = {}) {
         console.log('[SessionManager] 🚀 Starting session:', id);
         const startOperation = this.reserveInitialStartOperation(id);
         try {
@@ -527,7 +559,9 @@ export class SessionManager {
             // publication inside startRuntimeTurn(). A later stop is then observed by
             // the runtime admission signal instead of being lost between the gates.
             startOperation.throwIfStopped();
-            await this.startRuntimeTurn(session, session.prompt, session.externalSessionId, session.providerId, 'load', undefined, true);
+            if (input.deliveryId)
+                this.appendUserMessageEntry(session, input.originalText ?? session.prompt, `user:${input.deliveryId}`, input.deliveryId);
+            await this.startRuntimeTurn(session, input.prompt ?? session.prompt, session.externalSessionId, session.providerId, 'load', undefined, true, undefined, false, input);
             return session;
         }
         finally {
@@ -662,13 +696,13 @@ export class SessionManager {
                 }
             }
             await this.waitForPendingAutoCommit(id);
-            const userEntryId = options.userEntryId ?? this.appendUserMessageEntry(session, message);
+            const userEntryId = this.appendUserMessageEntry(session, options.originalText ?? message, options.userEntryId, options.deliveryId);
             const agentSessionId = session.externalSessionId
                 ?? this.resolveAgentSessionId(id, session.logSnapshot);
             if (providerId && providerId !== session.providerId) {
                 await this.runtimeCoordinator.disposeSession(id);
             }
-            await this.startRuntimeTurn(session, message, agentSessionId, effectiveProviderId, resumeMode, userEntryId, false, expectedTeamRunInvocationId, true);
+            await this.startRuntimeTurn(session, message, agentSessionId, effectiveProviderId, resumeMode, userEntryId, false, expectedTeamRunInvocationId, true, options);
             return session;
         }
         finally {
@@ -865,9 +899,12 @@ export class SessionManager {
         clearAgentApiCredentials();
     }
     kickConversationQueue(sessionId) {
-        if (this.conversationQueueStopping || this.conversationQueueWorkers.has(sessionId)) {
+        if (this.conversationQueueStopping) {
+            this.pendingConversationQueueKicks.add(sessionId);
             return;
         }
+        if (this.conversationQueueWorkers.has(sessionId))
+            return;
         const worker = new Promise((resolve, reject) => {
             setImmediate(() => {
                 this.processConversationQueue(sessionId).then(resolve, reject);
@@ -915,6 +952,7 @@ export class SessionManager {
             });
             if (claimed.count !== 1)
                 continue;
+            let submission;
             try {
                 console.log(`[ConversationQueue] claimed session=${sessionId} turn=${queued.id} queueWaitMs=${Math.max(0, Date.now() - queued.queuedAt.getTime())} attempt=${queued.attempts + 1}`);
                 // A conversation accepts one ACP prompt at a time. Waiting here keeps
@@ -931,8 +969,13 @@ export class SessionManager {
                 if (!session)
                     throw new NotFoundError('Session', sessionId);
                 this.ensureExecutionRecordIsLive(session);
+                submission = queued.deliveryId ? await this.deliveryService?.claim(queued.deliveryId, queued.deliveryRevision ?? undefined) : undefined;
+                if (queued.deliveryId && !submission) {
+                    await prisma.conversationTurn.updateMany({ where: { id: queued.id, status: CONVERSATION_TURN_RUNNING, deliveryRevision: queued.deliveryRevision }, data: { status: 'PAUSED' } });
+                    return;
+                }
                 const userEntryId = queued.userEntryId ?? `user:${queued.id}`;
-                this.appendUserMessageEntry(session, queued.message, userEntryId);
+                this.appendUserMessageEntry(session, queued.originalText ?? queued.message, userEntryId, queued.deliveryId ?? undefined);
                 if (!queued.userEntryId) {
                     await prisma.conversationTurn.updateMany({
                         where: { id: queued.id, status: CONVERSATION_TURN_RUNNING },
@@ -940,7 +983,8 @@ export class SessionManager {
                     });
                 }
                 const dispatchStartedAt = Date.now();
-                await this.sendMessage(sessionId, queued.message, queued.providerId ?? undefined, undefined, { userEntryId });
+                await this.sendMessage(sessionId, queued.message, queued.providerId ?? undefined, undefined, { userEntryId, originalText: queued.originalText ?? undefined, deliveryId: queued.deliveryId ?? undefined, ...submission });
+                await submission?.settle();
                 console.log(`[ConversationQueue] dispatched session=${sessionId} turn=${queued.id} dispatchMs=${Date.now() - dispatchStartedAt}`);
                 const turnWaitStartedAt = Date.now();
                 await this.runtimeCoordinator.waitForTurnCompletion(sessionId);
@@ -954,8 +998,10 @@ export class SessionManager {
                 console.log(`[ConversationQueue] completed session=${sessionId} turn=${queued.id} runtimeWaitMs=${Date.now() - turnWaitStartedAt}`);
             }
             catch (error) {
+                await submission?.settle();
                 if (this.conversationQueueStopping) {
-                    await this.requeueConversationTurn(queued.id);
+                    if (!queued.deliveryId)
+                        await this.requeueConversationTurn(queued.id);
                     return;
                 }
                 const lastError = error instanceof Error ? error.message : String(error);
@@ -1004,7 +1050,7 @@ export class SessionManager {
         }
         return null;
     }
-    async startRuntimeTurn(session, prompt, resumeExternalSessionId, providerId = session.providerId, resumeMode = 'load', historyBoundaryEntryId, initialStart = false, expectedTeamRunInvocationId, advanceGeneration = false) {
+    async startRuntimeTurn(session, prompt, resumeExternalSessionId, providerId = session.providerId, resumeMode = 'load', historyBoundaryEntryId, initialStart = false, expectedTeamRunInvocationId, advanceGeneration = false, submission = {}) {
         const workingDir = this.getExecutionWorkingDir(session);
         let launchClaimNumber = null;
         let admissionEntered = false;
@@ -1066,6 +1112,9 @@ export class SessionManager {
                             this.logSessionError('session.snapshotRestore', error, { sessionId: session.id });
                         }
                     }
+                    msgStore.textBlocks.admission = session.purpose === SessionPurpose.CHAT
+                        ? () => getTranslationService().getAdmissionEpoch()
+                        : () => undefined;
                     // Every turn claim is durable before RuntimeCoordinator can call a driver.
                     // The lease remains held until runTurn has either failed before spawn or
                     // handed the child/transport to its DriverSession owner.
@@ -1097,6 +1146,8 @@ export class SessionManager {
                         resumeExternalSessionId,
                         resumeMode,
                         historyBoundaryEntryId,
+                        onSubmitting: submission.onSubmitting,
+                        onSubmitted: submission.onSubmitted,
                         launchClaimNumber,
                         admission,
                     });
@@ -1300,6 +1351,21 @@ export class SessionManager {
     handleRuntimeTurnEvent(envelope) {
         const sessionId = envelope.towerSessionId;
         const event = envelope.event;
+        if (event.type === 'text_block') {
+            const block = event.entry.metadata?.textBlock;
+            if (block?.translationEpoch !== undefined && (block.state !== 'OPEN' || block.sourceRevision > 1)) {
+                this.dirtySnapshots.add(sessionId);
+                // Coalesce same-tick boundaries through the existing single snapshot writer.
+                if (!this.translationBoundaryPending.has(sessionId)) {
+                    this.translationBoundaryPending.add(sessionId);
+                    queueMicrotask(() => {
+                        this.translationBoundaryPending.delete(sessionId);
+                        void this.flushSnapshotPersist(sessionId).catch(() => this.scheduleSnapshotPersist(sessionId));
+                    });
+                }
+            }
+            return;
+        }
         if (event.type === 'stdout') {
             this.eventBus.emit('session:stdout', { sessionId, data: event.data });
             return;
@@ -2009,6 +2075,12 @@ export class SessionManager {
             });
             if (snapshotChanged) {
                 this.persistedSnapshotHashes.set(sessionId, snapshotHash);
+                if (serializedSnapshot.includes('"translationEpoch":')) {
+                    try {
+                        getTranslationService().checkpointCommitted(sessionId);
+                    }
+                    catch { /* Original snapshot is durable for startup recovery. */ }
+                }
             }
             if (DEBUG_SNAPSHOT) {
                 console.log(`[SessionManager:snapshot] flush persisted sessionId=${sessionId} status=${pendingStatus ?? 'unchanged'} entries=${snapshot.entries.length} changed=${snapshotChanged}`);
@@ -2052,7 +2124,7 @@ export class SessionManager {
             },
         });
     }
-    appendUserMessageEntry(session, message, entryId) {
+    appendUserMessageEntry(session, message, entryId, deliveryId) {
         const sessionId = session.id;
         const isNewStore = !sessionMsgStoreManager.has(sessionId);
         const msgStore = sessionMsgStoreManager.getOrCreate(sessionId);
@@ -2083,6 +2155,8 @@ export class SessionManager {
                 return entryId;
         }
         const userEntry = createUserMessage(message, entryId);
+        if (deliveryId)
+            userEntry.metadata = { ...userEntry.metadata, deliveryId };
         const userIndex = msgStore.entryIndex.next();
         const userPatch = addNormalizedEntry(userIndex, userEntry);
         if (DEBUG_SNAPSHOT) {