evolcore 0.0.1 → 0.0.2

package/dist/channels/daemon.js

@@ -0,0 +1,422 @@
+import { resolvePeerRoleDetail } from '../config/peer-role-resolver.js';
+const DEFAULT_WATCHDOG_MS = 11 * 60 * 1000;
+export class DaemonChannel {
+    sessionManager;
+    messageQueue;
+    channelName = 'daemon';
+    channelKey = 'daemon';
+    capabilities = {
+        file: true,
+        image: false,
+        interaction: false,
+        markdown: true,
+        thought: true,
+        status: true,
+        thread: true,
+    };
+    pending = new Map();
+    watchdogMs;
+    totalExecutionMs;
+    constructor(sessionManager, messageQueue, opts = {}) {
+        this.sessionManager = sessionManager;
+        this.messageQueue = messageQueue;
+        this.watchdogMs = normalizeWatchdogMs(opts.watchdogMs);
+        this.totalExecutionMs = normalizeTotalExecutionMs(opts.totalExecutionMs);
+    }
+    async converse(prompt, ctx) {
+        const runId = ctx.runId;
+        const pendingId = ctx.attemptId ?? runId;
+        const messageId = pendingId;
+        const startedAt = Date.now();
+        const promise = new Promise((resolve) => {
+            const watchdogTimer = setTimeout(() => this.watchdogTimeout(pendingId), this.watchdogMs);
+            watchdogTimer.unref?.();
+            const totalExecutionTimer = setTimeout(() => this.totalExecutionTimeout(pendingId), this.totalExecutionMs);
+            totalExecutionTimer.unref?.();
+            this.pending.set(pendingId, {
+                resolve,
+                startedAt,
+                watchdogTimer,
+                totalExecutionTimer,
+                waitingForAction: false,
+                onStateChange: ctx.onStateChange,
+                messageId,
+                abortSignal: ctx.signal,
+                runId,
+                acc: { text: '', files: [], anomalies: [], toolCallCount: 0, seenToolCallIds: new Set() },
+            });
+        });
+        const message = {
+            channel: this.channelName,
+            channelType: this.channelName,
+            channelId: ctx.session.channelId,
+            selfAID: ctx.trigger.agentAid,
+            baseagent: ctx.baseagent,
+            threadId: ctx.session.threadId || '',
+            chatType: 'private',
+            peerId: `trigger:${ctx.trigger.id}`,
+            peerName: ctx.trigger.name,
+            peerType: 'system',
+            content: prompt,
+            messageId,
+            timestamp: Date.now(),
+            source: 'trigger',
+            causation: ctx.causation,
+            replyContext: { metadata: { triggerRunId: runId, triggerAttemptId: pendingId } },
+            triggerMeta: {
+                triggerId: ctx.trigger.id,
+                runId,
+                attemptId: ctx.attemptId,
+                triggerName: ctx.trigger.name,
+                fireTime: ctx.firedAt,
+                boundSessionId: ctx.session.id,
+                modelOverride: ctx.trigger.execution.model,
+                effortOverride: ctx.trigger.execution.effort,
+                permissionModeOverride: ctx.trigger.execution.permissionMode,
+                originPeerId: ctx.trigger.origin?.peerId,
+                originChannelKey: ctx.trigger.origin?.channelKey,
+                originChannelType: ctx.trigger.origin?.channelType
+                    ?? (ctx.trigger.origin?.channelKey ? channelTypeFromKey(ctx.trigger.origin.channelKey) : undefined),
+                originControl: ctx.trigger.origin?.channelKey === 'daemon',
+            },
+        };
+        const onAbort = () => {
+            const reason = ctx.signal?.reason instanceof Error
+                ? ctx.signal.reason.message
+                : 'trigger execution cancelled';
+            const slot = this.pending.get(pendingId);
+            if (!slot || slot.terminalClaim)
+                return;
+            slot.acc.error = { reason: 'cancelled', text: reason };
+            if (!this.claimTerminal(slot, 'error'))
+                return;
+            const barrier = this.cancelDelivery(messageId);
+            slot.cancellationBarrier = barrier;
+            const finalize = () => this.settleTerminal(pendingId, slot);
+            void barrier.then(finalize, finalize);
+        };
+        const slot = this.pending.get(pendingId);
+        if (slot && ctx.signal) {
+            slot.abortListener = onAbort;
+            ctx.signal.addEventListener('abort', onAbort, { once: true });
+        }
+        if (ctx.signal?.aborted)
+            onAbort();
+        if (!slot?.terminalClaim) {
+            void this.messageQueue.enqueue(ctx.session.id, message, ctx.projectPath, {
+                interruptible: false,
+                agentName: ctx.trigger.agentAid,
+                sessionKeyField: ctx.session.sessionKey,
+                selfAID: ctx.trigger.agentAid,
+                role: this.triggerOriginRole(ctx.trigger),
+                signal: ctx.signal,
+            }).catch((err) => {
+                if (ctx.signal?.aborted)
+                    return;
+                this.fail(pendingId, 'enqueue_error', err?.message || String(err));
+            });
+        }
+        return promise;
+    }
+    async send(envelope, payload) {
+        const runId = this.runIdFromEnvelope(envelope);
+        if (!runId)
+            return;
+        const slot = this.pending.get(runId);
+        if (!slot || slot.terminalClaim)
+            return;
+        if (payload.kind !== 'status.requires_action')
+            this.resetWatchdog(runId, slot);
+        switch (payload.kind) {
+            case 'activity.batch':
+                for (const item of payload.items) {
+                    if (item.kind === 'tool_call')
+                        this.recordToolCall(slot, item.call_id);
+                }
+                break;
+            case 'result.text':
+                if (payload.isFinal)
+                    slot.acc.text = payload.text;
+                else
+                    slot.acc.text += payload.text;
+                break;
+            case 'result.file':
+                slot.acc.files.push({ path: payload.filePath, name: payload.fileName });
+                break;
+            case 'result.error':
+                slot.acc.error = { reason: payload.reason, text: payload.text };
+                this.finish(runId, 'error', { errorType: payload.reason ?? 'result_error' });
+                break;
+            case 'system.error':
+                slot.acc.error = { reason: payload.subtype, text: payload.text };
+                this.finish(runId, 'error', { errorType: payload.subtype });
+                break;
+            case 'status.progress':
+                if (payload.metadata?.activityType === 'execution_anomaly') {
+                    this.recordExecutionAnomaly(runId, payload.metadata?.anomaly);
+                }
+                if (slot.waitingForAction && payload.metadata?.state === 'processing') {
+                    slot.waitingForAction = false;
+                    slot.onStateChange?.('running', payload.metadata);
+                    this.resetWatchdog(runId, slot);
+                }
+                if (payload.metadata?.activityType === 'tool_call')
+                    this.recordToolCall(slot, payload.metadata.callId);
+                break;
+            case 'status.requires_action':
+                slot.waitingForAction = true;
+                if (slot.watchdogTimer)
+                    clearTimeout(slot.watchdogTimer);
+                slot.watchdogTimer = undefined;
+                slot.onStateChange?.('requires_action', payload.metadata);
+                break;
+            case 'status.completed':
+                this.finish(runId, 'success', payload.metadata);
+                break;
+            case 'status.error':
+                if (payload.metadata?.message) {
+                    slot.acc.error = {
+                        reason: payload.metadata.errorType ?? 'status_error',
+                        text: payload.metadata.message,
+                    };
+                }
+                this.finish(runId, 'error', payload.metadata);
+                break;
+            case 'status.interrupted':
+                {
+                    const reason = typeof payload.metadata?.reason === 'string' ? payload.metadata.reason : 'interrupted';
+                    slot.acc.error = { reason, text: `trigger execution interrupted: ${reason}` };
+                }
+                this.finish(runId, 'interrupted', payload.metadata);
+                break;
+            case 'status.timeout':
+                this.finish(runId, 'timeout', payload.metadata);
+                break;
+        }
+    }
+    recordExecutionActivity(pendingId) {
+        const slot = this.pending.get(pendingId);
+        if (!slot || slot.terminalClaim)
+            return false;
+        this.resetWatchdog(pendingId, slot);
+        return true;
+    }
+    async getOrCreateConversationSession(trigger, projectPath, baseagent, runId, attemptId) {
+        const channelId = `trigger:${trigger.id}`;
+        const threadId = trigger.execution.thread === 'per_run'
+            ? `trigger:${trigger.id}:${attemptId ?? runId}`
+            : `trigger:${trigger.id}`;
+        return await this.sessionManager.getOrCreateSession(this.channelName, channelId, projectPath, threadId, { channelKey: this.channelKey, peerId: `trigger:${trigger.id}`, peerName: trigger.name }, trigger.name, undefined, 'private', baseagent, trigger.agentAid, this.channelName, 'system');
+    }
+    /** Internal Trigger audit hook. It does not emit user-visible output. */
+    recordExecutionAnomaly(runId, value) {
+        const slot = this.pending.get(runId);
+        if (!slot || slot.terminalClaim)
+            return false;
+        const anomaly = normalizeExecutionAnomaly(value);
+        if (!anomaly)
+            return false;
+        slot.acc.anomalies.push(anomaly);
+        return true;
+    }
+    runIdFromEnvelope(envelope) {
+        const metadata = envelope.replyContext?.metadata;
+        const pendingId = metadata?.triggerAttemptId ?? metadata?.triggerRunId;
+        return typeof pendingId === 'string' ? pendingId : undefined;
+    }
+    recordToolCall(slot, callId) {
+        if (typeof callId !== 'string' || !callId) {
+            slot.acc.toolCallCount += 1;
+            return;
+        }
+        if (slot.acc.seenToolCallIds.has(callId))
+            return;
+        slot.acc.seenToolCallIds.add(callId);
+        slot.acc.toolCallCount += 1;
+    }
+    triggerOriginRole(trigger) {
+        const origin = trigger.origin;
+        if (!origin?.peerId)
+            return undefined;
+        if (origin.channelKey === 'daemon')
+            return 'owner';
+        const channelType = origin.channelType
+            ?? (origin.channelKey ? channelTypeFromKey(origin.channelKey) : undefined);
+        if (!channelType)
+            return undefined;
+        return resolvePeerRoleDetail({
+            selfAid: trigger.agentAid,
+            channelKey: origin.channelKey,
+            channelType,
+            chatType: 'private',
+            actorId: origin.peerId,
+            conversationId: origin.peerId,
+        }).effectiveRole ?? undefined;
+    }
+    finish(runId, status, metadata) {
+        const slot = this.pending.get(runId);
+        if (!slot || !this.claimTerminal(slot, status, metadata))
+            return;
+        this.settleTerminal(runId, slot);
+    }
+    claimTerminal(slot, outcome, metadata) {
+        if (slot.terminalClaim)
+            return false;
+        slot.terminalClaim = { outcome, metadata };
+        if (slot.watchdogTimer)
+            clearTimeout(slot.watchdogTimer);
+        clearTimeout(slot.totalExecutionTimer);
+        if (slot.abortListener)
+            slot.abortSignal?.removeEventListener('abort', slot.abortListener);
+        return true;
+    }
+    settleTerminal(runId, slot) {
+        if (this.pending.get(runId) !== slot || !slot.terminalClaim)
+            return;
+        this.pending.delete(runId);
+        const { outcome: status, metadata } = slot.terminalClaim;
+        const durationMs = typeof metadata?.durationMs === 'number'
+            ? metadata.durationMs
+            : Math.max(0, Date.now() - slot.startedAt);
+        const completedToolCallCount = typeof metadata?.toolCallCount === 'number' && Number.isFinite(metadata.toolCallCount)
+            ? Math.max(0, Math.trunc(metadata.toolCallCount))
+            : 0;
+        const text = slot.acc.text;
+        const outcome = status === 'success' && (slot.acc.error || !text.trim()) ? (slot.acc.error ? 'error' : 'noop') : status;
+        slot.resolve({
+            outcome,
+            text,
+            files: slot.acc.files,
+            error: slot.acc.error,
+            ...(slot.acc.anomalies.length ? { anomalies: slot.acc.anomalies } : {}),
+            meta: {
+                runId: slot.runId,
+                durationMs,
+                numTurns: typeof metadata?.numTurns === 'number' ? metadata.numTurns : undefined,
+                tokenUsage: isObject(metadata?.tokenUsage) ? metadata.tokenUsage : undefined,
+                contextUsage: metadata?.contextUsage,
+                toolCallCount: Math.max(slot.acc.toolCallCount, completedToolCallCount),
+            },
+        });
+    }
+    fail(runId, reason, text) {
+        const slot = this.pending.get(runId);
+        if (!slot || slot.terminalClaim)
+            return;
+        slot.acc.error = { reason, text };
+        this.finish(runId, 'error');
+    }
+    watchdogTimeout(runId) {
+        const slot = this.pending.get(runId);
+        if (!slot || slot.terminalClaim)
+            return;
+        slot.acc.error = {
+            reason: 'daemon_watchdog_timeout',
+            text: `daemon conversation watchdog timed out after ${this.watchdogMs}ms`,
+        };
+        if (!this.claimTerminal(slot, 'error', {
+            errorType: 'daemon_watchdog_timeout',
+            watchdogMs: this.watchdogMs,
+        }))
+            return;
+        this.cancelDeliveryInBackground(slot);
+        this.settleTerminal(runId, slot);
+    }
+    resetWatchdog(runId, slot) {
+        if (slot.waitingForAction || slot.terminalClaim)
+            return;
+        if (slot.watchdogTimer)
+            clearTimeout(slot.watchdogTimer);
+        slot.watchdogTimer = setTimeout(() => this.watchdogTimeout(runId), this.watchdogMs);
+        slot.watchdogTimer.unref?.();
+    }
+    totalExecutionTimeout(runId) {
+        const slot = this.pending.get(runId);
+        if (!slot || slot.terminalClaim)
+            return;
+        slot.acc.error = {
+            reason: 'daemon_total_execution_timeout',
+            text: `daemon conversation exceeded total execution limit of ${this.totalExecutionMs}ms`,
+        };
+        if (!this.claimTerminal(slot, 'timeout', {
+            errorType: 'daemon_total_execution_timeout',
+            totalExecutionMs: this.totalExecutionMs,
+        }))
+            return;
+        this.cancelDeliveryInBackground(slot);
+        this.settleTerminal(runId, slot);
+    }
+    cancelDeliveryInBackground(slot) {
+        const cancellation = this.cancelDelivery(slot.messageId);
+        slot.cancellationBarrier = cancellation;
+        void cancellation.then(() => undefined, () => undefined);
+    }
+    async cancelDelivery(messageId) {
+        const queue = this.messageQueue;
+        if (queue.cancel?.(messageId))
+            return;
+        if (queue.cancelActiveAndWait) {
+            await queue.cancelActiveAndWait(messageId);
+            return;
+        }
+        queue.cancelActive?.(messageId);
+    }
+}
+function isObject(value) {
+    return !!value && typeof value === 'object' && !Array.isArray(value);
+}
+function normalizeWatchdogMs(value) {
+    return typeof value === 'number' && Number.isFinite(value) && value > 0
+        ? value
+        : DEFAULT_WATCHDOG_MS;
+}
+function normalizeTotalExecutionMs(value) {
+    return typeof value === 'number' && Number.isFinite(value) && value > 0
+        ? value
+        : 60 * 60 * 1000;
+}
+function channelTypeFromKey(channelKey) {
+    const idx = channelKey.indexOf('#');
+    return idx > 0 ? channelKey.slice(0, idx) : channelKey;
+}
+function normalizeExecutionAnomaly(value) {
+    if (!isObject(value))
+        return undefined;
+    const allowedCodes = new Set([
+        'runtime_permission_denied',
+        'operation_blocked',
+        'capability_unavailable',
+    ]);
+    const code = value.code;
+    const effect = value.effect;
+    if (typeof code !== 'string' || !allowedCodes.has(code))
+        return undefined;
+    if (effect !== 'operation_skipped' && effect !== 'fallback_used')
+        return undefined;
+    const occurredAt = typeof value.occurredAt === 'number' && Number.isFinite(value.occurredAt)
+        ? value.occurredAt
+        : Date.now();
+    const toolName = nonEmptyString(value.toolName);
+    const requestId = nonEmptyString(value.requestId);
+    const policy = normalizeApproverPolicy(value.policy);
+    const summary = nonEmptyString(value.summary);
+    return {
+        code: code,
+        severity: 'warning',
+        phase: 'execution',
+        occurredAt,
+        effect,
+        ...(toolName ? { toolName } : {}),
+        ...(requestId ? { requestId } : {}),
+        ...(policy ? { policy } : {}),
+        ...(summary ? { summary: summary.slice(0, 512) } : {}),
+    };
+}
+function nonEmptyString(value) {
+    return typeof value === 'string' && value.trim() ? value.trim() : undefined;
+}
+function normalizeApproverPolicy(value) {
+    return value === 'requester' || value === 'agent_manager' || value === 'agent_owner'
+        ? value
+        : undefined;
+}