@0xmaxma/claude-gateway 2.0.12 → 2.0.14

package/dist/orchestration/runtime.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.AgentOrchestrationRuntime = exports.GATEWAY_TASK_INSTRUCTIONS = void 0;
 exports.readRequestDirective = readRequestDirective;
 exports.agentHandoffDirective = agentHandoffDirective;
+const input_batch_1 = require("./input-batch");
 const computer_prompt_1 = require("./computer-prompt");
 const control_notification_1 = require("./control-notification");
 const computer_choice_ids_1 = require("../automation/computer-choice-ids");
@@ -91,6 +92,7 @@ const bounded_queue_1 = require("./bounded-queue");
 const capacity_1 = require("./capacity");
 const cleanup_1 = require("./tasks/cleanup");
 const task_files_1 = require("./task-files");
+const narrate_1 = require("./narrate");
 const worker_shares_1 = require("./worker-shares");
 const provider_admission_1 = require("./provider-admission");
 const provider_scope_1 = require("./provider-scope");
@@ -322,6 +324,10 @@ class AgentOrchestrationRuntime {
             progress: (task, report) => store.transaction(() => { const current = store.task(task.taskId); if (!current || current.activeAttemptId !== task.activeAttemptId || !['starting', 'running', 'interrupting'].includes(current.state))
                 return; current.computerReport = report; current.latestProgress = { source: 'runtime', observedAt: Date.now(), text: `Computer Use: ${report.phase} · ${report.steps} actions · ${report.evaluations ?? 0} evaluations.${current.queuedCommands?.length ? ` ${current.queuedCommands.length} queued command${current.queuedCommands.length === 1 ? '' : 's'} waiting.` : ''}` }; store.saveTask(current, current.stateVersion); }) }));
         const bridge = new bridge_1.TaskBridge(tasks, files, (0, worker_shares_1.workerShares)(files, agent, gateway), host.skills ? () => host.skills() : undefined, agent.type === 'app-agent' ? { agent, spool: (0, path_1.join)(root, 'container-files') } : undefined, (0, worker_crons_1.workerCrons)(files, agent, gateway), gatewayAdapters);
+        const voiceConfig = () => (0, config_2.resolveOrchestrationConfig)(agent.orchestration, agent.voice ?? { enabled: false }).voice;
+        const narrateVoices = new telegram_voices_1.TelegramVoices(store, () => voiceConfig().tts);
+        bridge.narrateCall = (0, narrate_1.workerNarrate)({ files, config: () => voiceConfig().narrate, voiceEnabled: () => voiceConfig().enabled,
+            settings: chat => narrateVoices.settings((0, store_1.channelVoiceKey)(chat.source, chat.chat_id, chat.thread_key ?? '')) });
         bridge.computerEnabled = computerAllowed;
         bridge.jevEnabled = () => (0, jev_gateway_1.jevAllowed)(gateway, agent);
         bridge.browserEnabled = () => Boolean(gateway.gateway.jev?.browser) && (0, jev_gateway_1.jevAllowed)(gateway, agent) && gateway.gateway.jev?.features?.browserTasks?.enabled === true;
@@ -1124,12 +1130,18 @@ class AgentOrchestrationRuntime {
                 mailboxCursor = Number(row.mailbox_row);
                 if (this.active.size >= this.config.conversation.maxActiveSessions)
                     break;
-                const input = JSON.parse(String(row.ingress_json));
-                if (!input.scope || !input.capabilities || this.active.has(input.scope.agentSessionId))
+                // Batch members share the row's conversation and session, so admission is
+                // decided before scanning later rows for the batch.
+                const head = JSON.parse(String(row.ingress_json));
+                if (!head.scope || !head.capabilities || this.active.has(head.scope.agentSessionId))
                     continue;
-                if (visitedSessions.has(input.scope.agentSessionId))
+                if (visitedSessions.has(head.scope.agentSessionId))
+                    continue;
+                visitedSessions.add(head.scope.agentSessionId);
+                const batch = (0, input_batch_1.inputBatch)(this.store, row, this.batchDebounceMs(), this.config.conversation.inputMaxWaitMs);
+                const input = batch.input;
+                if (Date.now() < batch.readyAt)
                     continue;
-                visitedSessions.add(input.scope.agentSessionId);
                 const scope = (0, provider_scope_1.resolveProviderScope)(this.agent, this.gateway, input.model, 'agent');
                 const waiting = this.providerAdmission.inspect(scope, this.config.providerAdmission);
                 if (waiting) {
@@ -1140,7 +1152,7 @@ class AgentOrchestrationRuntime {
                 }
                 // A persisted input retains the authenticated scope and model from ingress.
                 // Recovery can repeat inference, but committed tool receipts remain fenced.
-                const result = this.send({ ...input, acceptedInputId: String(row.id) }, input.capabilities, { timeoutMs: this.config.conversation.maxDecisionDurationMs, model: input.model, onTool: event => this.inputTools.get(String(row.id))?.(event), onText: text => {
+                const result = this.send({ ...input, acceptedInputId: String(batch.last.id) }, input.capabilities, { inputIds: batch.inputIds, timeoutMs: this.config.conversation.maxDecisionDurationMs, model: input.model, onTool: event => this.inputTools.get(String(row.id))?.(event), onText: text => {
                         const responseId = this.responseIdForInput(String(row.id));
                         if (input.modality !== 'live_voice' && responseId) {
                             try {
@@ -1149,13 +1161,26 @@ class AgentOrchestrationRuntime {
                             catch { /* slow audio cannot stall inference */ }
                         }
                     } });
-                void result.then(text => this.deferred.get(String(row.id))?.resolve(text), error => this.deferred.get(String(row.id))?.reject(error))
-                    .finally(() => this.deferred.delete(String(row.id)));
+                void result.then(text => {
+                    // Superseded, uncommitted inputs remain durable and their callers wait
+                    // for the replacement decision rather than receiving an empty answer.
+                    for (const id of batch.inputIds)
+                        if (this.store.get('SELECT status FROM conversation_inputs WHERE id=?', id)?.status === 'handled') {
+                            this.deferred.get(id)?.resolve(text);
+                            this.deferred.delete(id);
+                        }
+                }, error => { for (const id of batch.inputIds) {
+                    this.deferred.get(id)?.reject(error);
+                    this.deferred.delete(id);
+                } });
             }
             if (this.active.size >= this.config.conversation.maxActiveSessions)
                 break mailbox;
         }
     }
+    batchDebounceMs() {
+        return this.config.conversation.semanticIntake ? this.config.conversation.inputDebounceMs : 0;
+    }
     async run(input, capabilities, options) {
         const sessionId = input.scope.agentSessionId;
         const channelTts = this.telegramVoices.settings((0, store_1.channelVoiceKey)(input.scope.source, input.scope.chatId, input.scope.threadKey));
@@ -1205,7 +1230,7 @@ class AgentOrchestrationRuntime {
                 this.store.run("UPDATE conversations SET status='draining' WHERE id=?", receipt.conversationId);
             this.seenSessions.add(sessionId);
             this.questionControls.tick();
-            const decision = this.decisions.begin(receipt.conversationId, input.scope.principalId, [receipt.inputId], input.requestId);
+            const decision = this.decisions.begin(receipt.conversationId, input.scope.principalId, options.inputIds ?? [receipt.inputId], input.requestId);
             active.decision = decision;
             if (questionReview) {
                 // Notifications may arrive after this internal input was queued. A
@@ -1272,9 +1297,9 @@ class AgentOrchestrationRuntime {
             const semantic = this.config.conversation.semanticIntake && !active.notification && !liveControl;
             const prepared = semantic ? this.intake.context(receipt.conversationId, input.scope.principalId, String(admitted.binding_id)) : undefined;
             const recoveryInputId = input.ingressKey?.startsWith('intake-recovery:') ? input.ingressKey.slice('intake-recovery:'.length) : undefined;
-            const preparedInputIds = [...new Set([...(prepared?.inputIds ?? []), ...(recoveryInputId ? [recoveryInputId] : [])])];
+            const preparedInputIds = [...new Set([...(prepared?.inputIds ?? []), ...(!recoveryInputId && (prepared?.inputIds?.length || decision.inputIds.length > 1) ? decision.inputIds : []), ...(recoveryInputId ? [recoveryInputId] : [])])];
             const preparedInputs = preparedInputIds.length ? this.store.all(`SELECT id,text,attachment_refs_json,ingress_json FROM conversation_inputs
-        WHERE conversation_id=? AND principal_id=? AND binding_id=? AND id IN (SELECT value FROM json_each(?))`, receipt.conversationId, input.scope.principalId, admitted.binding_id, JSON.stringify(preparedInputIds)) : [];
+        WHERE conversation_id=? AND principal_id=? AND binding_id=? AND id IN (SELECT value FROM json_each(?)) ORDER BY input_seq`, receipt.conversationId, input.scope.principalId, admitted.binding_id, JSON.stringify(preparedInputIds)) : [];
             const preparedRefs = preparedInputs.flatMap(row => JSON.parse(String(row.attachment_refs_json)));
             if (preparedRefs.length)
                 input = { ...input, attachmentIds: [...new Set([...(input.attachmentIds ?? []), ...preparedRefs])] };
@@ -1309,14 +1334,18 @@ class AgentOrchestrationRuntime {
             }
             // Immutable source IDs remain available to workers. Only the model delivery
             // is incremental; full canonical text and attachment references are retained.
-            const freshPreparedInputs = preparedInputs.filter(row => row.id !== receipt.inputId && !contextPlan.includes('materials', String(row.id)));
+            // Unresolved execution is an obligation, not optional cached context. Replay
+            // it on follow-up/recovery even when this CLI has seen it before.
+            const replayPending = Boolean(prepared?.deferredDispatch || recoveryInputId);
+            const freshPreparedInputs = preparedInputs.filter(row => row.id !== receipt.inputId && (replayPending || !contextPlan.includes('materials', String(row.id))));
             for (const row of freshPreparedInputs)
                 contextPlan.mark('materials', String(row.id), true);
             contextPlan.mark('materials', receipt.inputId, true);
             const intakeValue = (value) => value ? { mode: value.mode, deferredDispatch: value.deferredDispatch,
                 preparation: value.preparation, inputIds: value.inputIds, task_id: value.task_id, resolution: value.resolution } : null;
             const pendingState = intakeValue(prepared);
-            const pendingChanges = contextPlan.select('intake', [{ id: 'pending', value: pendingState }], row => row.id);
+            const pendingDelta = contextPlan.select('intake', [{ id: 'pending', value: pendingState }], row => row.id);
+            const pendingChanges = replayPending ? [{ id: 'pending', value: pendingState }] : pendingDelta;
             if (!semantic && input.skill && input.modality !== 'live_voice' && !channelSpeech && !visualInput.images.length && !visualInput.unavailable.length) {
                 const task = this.tasks.spawn({ ...capabilities, ...receipt, ...decision, principalId: input.scope.principalId,
                     model: options.model ?? this.agent.claude.model, actionId: `skill:${receipt.inputId}` }, {
@@ -1464,7 +1493,7 @@ class AgentOrchestrationRuntime {
                         return;
                     if (!intakeChoice || intakeChoice.mode === 'wait' || intakeChoice.mode === 'resolve' || !acknowledgementReady)
                         throw new types_2.OrchestrationError('ACKNOWLEDGEMENT_REQUIRED');
-                    if (tool === 'task_spawn' && preparedInputs.length)
+                    if (tool === 'task_spawn' && !args.gateway_target && preparedInputs.length)
                         args.context_refs = [...new Set([...(Array.isArray(args.context_refs) ? args.context_refs : []), ...preparedRefs, ...preparedInputs.map(row => String(row.id))])];
                     if (intakeChoice.mode === 'update' && (tool === 'task_spawn' || args.task_id !== intakeChoice.task_id)) {
                         const attempt = attemptedTaskActions.get(actionId);
@@ -1658,14 +1687,18 @@ class AgentOrchestrationRuntime {
                 await this.flushHistory();
                 return display;
             }
+            let unsafeToReplay = false;
             agentSession.on('output', (0, tool_activity_1.toolActivity)(event => {
+                if (event.type === 'tool_use' && !/^(StructuredOutput|mcp__gateway__(conversation_intake|capabilities_list|memory_get|memory_search|task_status))$/.test(event.name))
+                    unsafeToReplay = true;
                 this.store.transaction(() => this.store.appendEvent(receipt.conversationId, internalReview ? 'progress.review.tool' : 'tool.activity', { ...event, responseId: decision.responseId, role: 'agent' }));
                 if (!internalReview)
                     options.onTool?.(event);
             }));
+            const bufferChat = semantic && this.config.conversation.inputDebounceMs > 0 && (0, input_batch_1.batchableInput)(input);
             let rawDisplay = '', structuredStarted = false;
             const displayChunk = (chunk) => {
-                if (internalReview || questionReview)
+                if (internalReview || questionReview || bufferChat || recoveryInputId)
                     return; // Buffer until the notify/silence decision is final.
                 if (semantic && (intakeChoice?.mode === 'wait' || intakeDeferred || acknowledgementId))
                     return;
@@ -1721,6 +1754,28 @@ class AgentOrchestrationRuntime {
                 }
                 catch { /* Provider bookkeeping cannot invalidate a completed inference. */ }
             }
+            const committedAction = this.store.get('SELECT action_id FROM task_commands WHERE decision_id=? LIMIT 1', decision.decisionId);
+            const supersededCount = Number(this.store.get("SELECT count(*) n FROM conversation_events WHERE conversation_id=? AND type='response.superseded' AND json_extract(payload_json,'$.payload.inputId')=?", receipt.conversationId, decision.inputIds[0])?.n ?? 0);
+            // Supersede only when the batcher would now absorb newer input into this
+            // batch; an incompatible follow-up gets its own turn without re-inference.
+            const batchGrows = () => {
+                const first = this.store.get('SELECT * FROM conversation_inputs WHERE id=?', decision.inputIds[0]);
+                return !!first && (0, input_batch_1.inputBatch)(this.store, first, this.batchDebounceMs(), this.config.conversation.inputMaxWaitMs, decision.inputIds)
+                    .inputIds.some(id => !decision.inputIds.includes(id));
+            };
+            if (bufferChat && newerInputPending() && batchGrows() && !response.interrupted && !active.stopping && !acknowledgementId && !committedAction && !unsafeToReplay && supersededCount < 2) {
+                this.store.compose(() => {
+                    this.decisions.finish(decision, '', 'interrupted', undefined, false);
+                    for (const id of decision.inputIds)
+                        this.store.run("UPDATE conversation_inputs SET status='accepted' WHERE id=?", id);
+                    this.store.appendEvent(receipt.conversationId, 'response.superseded', { responseId: decision.responseId, inputId: decision.inputIds[0], inputIds: decision.inputIds });
+                });
+                // No user-visible answer or task action was committed. Re-read canonical
+                // inputs with the newer messages; do not checkpoint discarded context.
+                contextPlan.invalidate();
+                await this.flushHistory();
+                return '';
+            }
             if (!response.interrupted) {
                 // A completed CLI turn has consumed its tool results. Failed/interrupted
                 // turns never advance this checkpoint, so committed receipts can recover.
@@ -1806,7 +1861,20 @@ class AgentOrchestrationRuntime {
                             : 'The requested task was not started or updated. Please try again.';
                 surfaces.spoken = '';
             }
-            const intakeSilent = semantic && !uncommittedDispatch && (intakeChoice?.mode === 'wait' || intakeDeferred || (acknowledgementId && this.store.get("SELECT action_id FROM task_commands WHERE decision_id=? AND command_type IN ('spawn','update','answer') LIMIT 1", decision.decisionId)));
+            const dispatchCommitted = this.store.get("SELECT action_id FROM task_commands WHERE decision_id=? AND command_type IN ('spawn','update','answer') LIMIT 1", decision.decisionId);
+            if (semantic && !response.interrupted && !active.stopping && intakeChoice && ['ready', 'update'].includes(intakeChoice.mode) && !dispatchCommitted)
+                this.intake.deferDispatch(receipt.inputId);
+            const unresolved = semantic && this.intake.context(receipt.conversationId, input.scope.principalId, String(admitted.binding_id));
+            const recoveryFailed = Boolean(recoveryInputId && unresolved?.deferredDispatch && unresolved.mode !== 'wait' && !response.interrupted && !active.stopping && !newerInputPending());
+            if (recoveryFailed) {
+                const thai = /[\u0E00-\u0E7F]/.test(input.text + String(unresolved && unresolved.preparation) + preparedInputs.map(row => row.text).join('') + response.text);
+                surfaces.display = thai
+                    ? 'ระบบยังจัดการคำขอค้างไม่สำเร็จ: agent จบการกู้คืนโดยไม่ได้ยืนยันว่างานถูกส่งต่อหรือปิดเรื่องแล้ว คำขอเดิมยังถูกเก็บไว้และยังไม่ถือว่าเสร็จค่ะ'
+                    : 'The agent ended recovery without confirming that the pending request was dispatched or resolved. The request is still retained and is not complete.';
+                surfaces.spoken = '';
+                this.store.transaction(() => this.store.appendEvent(receipt.conversationId, 'response.dispatch_unresolved', { responseId: decision.responseId, inputId: receipt.inputId }));
+            }
+            const intakeSilent = !recoveryFailed && semantic && !uncommittedDispatch && (intakeChoice?.mode === 'wait' || intakeDeferred || (acknowledgementId && unresolved?.deferredDispatch && !dispatchCommitted) || (acknowledgementId && this.store.get("SELECT action_id FROM task_commands WHERE decision_id=? AND command_type IN ('spawn','update','answer') LIMIT 1", decision.decisionId)));
             if (intakeSilent) {
                 // A receipt/preparation turn has not reported older task results. Keep
                 // their notifications (and attachments) available to the next report.
@@ -1826,7 +1894,7 @@ class AgentOrchestrationRuntime {
                 for (const image of endScreenshots) {
                     (0, computer_end_screenshot_1.attachComputerEndScreenshot)(this.store, (0, path_1.join)(this.agent.workspace, '../..'), { ...image, responseId: decision.responseId, principalId: input.scope.principalId, conversationId: receipt.conversationId });
                 }
-            this.decisions.finish(decision, display, response.interrupted ? 'interrupted' : 'completed', channelSpeech && !silent ? taskSpeech || surfaces.spoken : undefined, !active.stopping && !silent);
+            this.decisions.finish(decision, display, response.interrupted ? 'interrupted' : recoveryFailed ? 'failed' : 'completed', channelSpeech && !silent ? taskSpeech || surfaces.spoken : undefined, !active.stopping && !silent);
             if (active.notification && !response.interrupted) {
                 const batch = this.store.get('SELECT COUNT(*)-COUNT(DISTINCT task_id) n FROM notifications WHERE decision_id=?', decision.decisionId);
                 try {