@murphai/murph 0.1.15 → 0.1.18

package/node_modules/@murphai/assistant-engine/dist/assistant/automation/reply.js

@@ -0,0 +1,790 @@
+import { createDefaultLocalAssistantModelTarget } from '@murphai/operator-config/assistant-backend';
+import { getAssistantChannelAdapter } from '../channel-adapters.js';
+import { conversationRefFromCapture } from '../conversation-ref.js';
+import { resolveAcceptedInboundMessageOperatorAuthority, } from '../operator-authority.js';
+import { resolveAssistantProviderCapabilities } from '../provider-registry.js';
+import { resolveAssistantOperatorDefaults, } from '@murphai/operator-config/operator-config';
+import { isAssistantProviderConnectionLostError, isAssistantProviderStalledError, } from '../provider-turn-recovery.js';
+import { listAssistantTurnReceipts } from '../receipts.js';
+import { errorMessage, normalizeNullableString } from '../shared.js';
+import { sendAssistantMessage } from '../service.js';
+import { resolveAssistantTurnRoutesForMessage, selectAssistantTurnRouteOverride, } from '../service-turn-routes.js';
+import { listAssistantTranscriptEntries, resolveAssistantSession, } from '../store.js';
+import { assistantAutoReplyGroupOutcomeArtifactExists, assistantChatReplyArtifactExists, writeAssistantAutoReplyGroupOutcomeArtifact, writeAssistantChatDeferredArtifacts, writeAssistantChatErrorArtifacts, writeAssistantChatResultArtifacts, } from './artifacts.js';
+import { describeAssistantAutoReplyFailure, } from './failure-observability.js';
+import { collectAssistantAutoReplyGroup, } from './grouping.js';
+import { AUTO_REPLY_PROVIDER_STALLED_DETAIL, createAssistantProviderWatchdog, } from './provider-watchdog.js';
+import { prepareAssistantAutoReplyInput, } from './prompt-builder.js';
+import { createEmptyAutoReplyScanResult, cursorFromCapture, normalizeEnabledChannels, normalizeScanLimit, } from './shared.js';
+const SELF_AUTHORED_ECHO_WINDOW_MS = 10 * 60 * 1000;
+const AUTO_REPLY_RECEIPT_CAPTURE_ID_KEY = 'autoReplyCaptureId';
+const AUTO_REPLY_RECEIPT_CAPTURE_IDS_KEY = 'autoReplyCaptureIds';
+export async function scanAssistantAutoReplyOnce(input) {
+    const enabledChannels = normalizeEnabledChannels(input.enabledChannels);
+    const backlogChannels = normalizeEnabledChannels(input.backlogChannels ?? []);
+    const backlogActive = backlogChannels.length > 0;
+    if (enabledChannels.length === 0) {
+        return createEmptyAutoReplyScanResult();
+    }
+    if (!(input.autoReplyPrimed ?? true) && !backlogActive) {
+        const latest = await input.inboxServices.list({
+            vault: input.vault,
+            requestId: input.requestId ?? null,
+            limit: 1,
+            sourceId: null,
+            afterOccurredAt: null,
+            afterCaptureId: null,
+            oldestFirst: false,
+        });
+        const latestCapture = [...latest.items].sort((left, right) => left.occurredAt === right.occurredAt
+            ? right.captureId.localeCompare(left.captureId)
+            : right.occurredAt.localeCompare(left.occurredAt))[0];
+        const nextCursor = latestCapture
+            ? {
+                occurredAt: latestCapture.occurredAt,
+                captureId: latestCapture.captureId,
+            }
+            : input.afterCursor ?? null;
+        await input.onStateProgress?.({
+            cursor: nextCursor,
+            primed: true,
+        });
+        input.onEvent?.({
+            type: 'reply.scan.primed',
+            details: nextCursor === null
+                ? 'no existing captures yet; auto-reply will start with the next inbound message'
+                : `starting after ${nextCursor.captureId}`,
+        });
+        return createEmptyAutoReplyScanResult();
+    }
+    if (backlogActive) {
+        input.onEvent?.({
+            type: 'reply.scan.primed',
+            details: `processing existing ${backlogChannels.join(', ')} backlog before switching to new inbound messages`,
+        });
+    }
+    const listed = await input.inboxServices.list({
+        vault: input.vault,
+        requestId: input.requestId ?? null,
+        limit: normalizeScanLimit(input.maxPerScan),
+        sourceId: null,
+        afterOccurredAt: input.afterCursor?.occurredAt ?? null,
+        afterCaptureId: input.afterCursor?.captureId ?? null,
+        oldestFirst: true,
+    });
+    const captures = [...listed.items].sort((left, right) => left.occurredAt === right.occurredAt
+        ? left.captureId.localeCompare(right.captureId)
+        : left.occurredAt.localeCompare(right.occurredAt));
+    input.onEvent?.({
+        type: 'reply.scan.started',
+        details: `${captures.length} capture(s)`,
+    });
+    if (backlogActive && captures.length === 0) {
+        await input.onStateProgress?.({
+            cursor: input.afterCursor ?? null,
+            backlogChannels: [],
+            primed: true,
+        });
+        return createEmptyAutoReplyScanResult();
+    }
+    const summary = createEmptyAutoReplyScanResult();
+    const scanState = {
+        cursor: input.afterCursor ?? null,
+    };
+    for (let index = 0; index < captures.length; index += 1) {
+        if (input.signal?.aborted) {
+            break;
+        }
+        const group = await collectAssistantAutoReplyGroup({
+            captures,
+            startIndex: index,
+            vault: input.vault,
+        });
+        index = group.endIndex;
+        summary.considered += group.items.length;
+        const context = createAssistantAutoReplyGroupContext(group.items);
+        if (!context) {
+            continue;
+        }
+        const result = await processAssistantAutoReplyGroup({
+            allowSelfAuthored: input.allowSelfAuthored ?? false,
+            context,
+            deliveryDispatchMode: input.deliveryDispatchMode,
+            enabledChannels,
+            inboxServices: input.inboxServices,
+            onEvent: input.onEvent,
+            providerHeartbeatMs: input.providerHeartbeatMs,
+            providerLongRunningCommandStallTimeoutMs: input.providerLongRunningCommandStallTimeoutMs,
+            providerStallTimeoutMs: input.providerStallTimeoutMs,
+            requestId: input.requestId ?? null,
+            signal: input.signal,
+            sessionMaxAgeMs: input.sessionMaxAgeMs ?? null,
+            vault: input.vault,
+        });
+        if (applyAssistantAutoReplyProcessResult({
+            context,
+            result,
+            summary,
+            updateCursor: (cursor) => {
+                scanState.cursor = cursor;
+            },
+        })) {
+            break;
+        }
+    }
+    await input.onStateProgress?.({
+        cursor: scanState.cursor,
+        primed: true,
+    });
+    return summary;
+}
+export function applyAssistantAutoReplyProcessResult(input) {
+    input.summary.failed += input.result.failed;
+    input.summary.replied += input.result.replied;
+    input.summary.skipped += input.result.skipped;
+    if (input.result.advanceCursor) {
+        input.updateCursor(input.context.lastCursor);
+    }
+    return input.result.stopScanning;
+}
+export function createAssistantAutoReplyGroupContext(items) {
+    const firstItem = items[0];
+    const lastItem = items[items.length - 1];
+    if (!firstItem || !lastItem) {
+        return null;
+    }
+    return {
+        captureCount: items.length,
+        captureIds: items.map((item) => item.summary.captureId),
+        firstCaptureId: firstItem.summary.captureId,
+        firstItem,
+        items,
+        lastCursor: cursorFromCapture(lastItem.summary),
+    };
+}
+export async function processAssistantAutoReplyGroup(input) {
+    const outcome = await resolveAssistantAutoReplyGroupOutcome(input);
+    return commitAssistantAutoReplyGroupOutcome({
+        context: input.context,
+        onEvent: input.onEvent,
+        outcome,
+        vault: input.vault,
+    });
+}
+async function resolveAssistantAutoReplyGroupOutcome(input) {
+    try {
+        const decision = await evaluateAssistantAutoReplyGroup({
+            allowSelfAuthored: input.allowSelfAuthored,
+            enabledChannels: input.enabledChannels,
+            group: input.context,
+            inboxServices: input.inboxServices,
+            requestId: input.requestId,
+            vault: input.vault,
+        });
+        if (decision.kind === 'ignore') {
+            return createIgnoredGroupOutcome();
+        }
+        if (decision.kind === 'skip') {
+            return createSkippedDecisionOutcome({
+                captureCount: input.context.captureCount,
+                decision,
+            });
+        }
+        input.onEvent?.({
+            type: 'capture.reply-started',
+            captureId: input.context.firstCaptureId,
+            details: 'assistant provider turn started',
+        });
+        const result = await executeAssistantAutoReply({
+            captureIds: input.context.captureIds,
+            deliveryDispatchMode: input.deliveryDispatchMode,
+            deliveryReplyToMessageId: decision.deliveryReplyToMessageId,
+            executionContext: input.executionContext,
+            providerHeartbeatMs: input.providerHeartbeatMs,
+            providerLongRunningCommandStallTimeoutMs: input.providerLongRunningCommandStallTimeoutMs,
+            providerStallTimeoutMs: input.providerStallTimeoutMs,
+            signal: input.signal,
+            maxSessionAgeMs: input.sessionMaxAgeMs,
+            onEvent: input.onEvent,
+            operatorAuthority: decision.operatorAuthority,
+            primaryCapture: decision.primaryCapture,
+            prompt: decision.prompt,
+            providerOverride: decision.providerOverride,
+            replyCaptureId: input.context.firstCaptureId,
+            userMessageContent: decision.userMessageContent,
+            vault: input.vault,
+        });
+        if (result.deliveryDeferred) {
+            return createDeferredDeliveryGroupOutcome(result);
+        }
+        return createSuccessfulReplyGroupOutcome(result);
+    }
+    catch (error) {
+        return classifyAssistantAutoReplyFailure({
+            captureCount: input.context.captureCount,
+            error,
+        });
+    }
+}
+async function commitAssistantAutoReplyGroupOutcome(input) {
+    await writeAssistantAutoReplyOutcomeArtifacts(input).catch((error) => {
+        if (input.outcome.artifact.kind === 'error') {
+            return;
+        }
+        throw error;
+    });
+    emitAssistantAutoReplyOutcomeEvent(input);
+    return {
+        advanceCursor: input.outcome.advanceCursor,
+        failed: input.outcome.summary.failed,
+        replied: input.outcome.summary.replied,
+        skipped: input.outcome.summary.skipped,
+        stopScanning: input.outcome.stopScanning,
+    };
+}
+async function writeAssistantAutoReplyOutcomeArtifacts(input) {
+    switch (input.outcome.artifact.kind) {
+        case 'none':
+            return;
+        case 'result': {
+            const delivery = input.outcome.artifact.result.delivery;
+            if (!delivery) {
+                throw new Error('assistant auto-reply delivery was missing after delivery confirmation');
+            }
+            await writeAssistantAutoReplyGroupOutcomeArtifact({
+                captureIds: input.context.captureIds,
+                outcome: 'result',
+                recordedAt: delivery.sentAt,
+                result: input.outcome.artifact.result,
+                vault: input.vault,
+            });
+            await writeAssistantChatResultArtifacts({
+                captureIds: input.context.captureIds,
+                respondedAt: delivery.sentAt,
+                result: input.outcome.artifact.result,
+                vault: input.vault,
+            });
+            return;
+        }
+        case 'deferred': {
+            const queuedAt = new Date().toISOString();
+            await writeAssistantAutoReplyGroupOutcomeArtifact({
+                captureIds: input.context.captureIds,
+                outcome: 'deferred',
+                recordedAt: queuedAt,
+                result: input.outcome.artifact.result,
+                vault: input.vault,
+            });
+            await writeAssistantChatDeferredArtifacts({
+                captureIds: input.context.captureIds,
+                queuedAt,
+                result: input.outcome.artifact.result,
+                vault: input.vault,
+            });
+            return;
+        }
+        case 'error':
+            await writeAssistantChatErrorArtifacts({
+                captureIds: input.context.captureIds,
+                failure: input.outcome.artifact.failure,
+                vault: input.vault,
+            });
+            return;
+    }
+}
+function emitAssistantAutoReplyOutcomeEvent(input) {
+    if (!input.outcome.event) {
+        return;
+    }
+    input.onEvent?.({
+        type: input.outcome.event.type,
+        captureId: input.context.firstCaptureId,
+        details: input.outcome.event.details,
+        errorCode: input.outcome.event.errorCode,
+        safeDetails: input.outcome.event.safeDetails,
+    });
+}
+function createIgnoredGroupOutcome() {
+    return {
+        advanceCursor: false,
+        artifact: { kind: 'none' },
+        event: null,
+        kind: 'ignored',
+        stopScanning: false,
+        summary: createAssistantAutoReplyOutcomeSummary(),
+    };
+}
+function createSkippedDecisionOutcome(input) {
+    if (input.decision.advanceCursor) {
+        return createSkippedGroupOutcome({
+            captureCount: input.captureCount,
+            reason: input.decision.reason,
+            stopScanning: input.decision.stopScanning,
+        });
+    }
+    return createDeferredGroupOutcome({
+        captureCount: input.captureCount,
+        reason: input.decision.reason,
+        stopScanning: input.decision.stopScanning,
+    });
+}
+function createSkippedGroupOutcome(input) {
+    return {
+        advanceCursor: true,
+        artifact: { kind: 'none' },
+        event: {
+            details: input.reason,
+            type: 'capture.reply-skipped',
+        },
+        kind: 'skipped',
+        stopScanning: input.stopScanning ?? false,
+        summary: createAssistantAutoReplyOutcomeSummary({
+            skipped: input.captureCount,
+        }),
+    };
+}
+function createDeferredGroupOutcome(input) {
+    return {
+        advanceCursor: false,
+        artifact: { kind: 'none' },
+        event: {
+            details: input.reason,
+            type: 'capture.reply-skipped',
+        },
+        kind: 'deferred',
+        stopScanning: input.stopScanning,
+        summary: createAssistantAutoReplyOutcomeSummary({
+            skipped: input.captureCount,
+        }),
+    };
+}
+function createDeferredDeliveryGroupOutcome(result) {
+    return {
+        advanceCursor: true,
+        artifact: {
+            kind: 'deferred',
+            result,
+        },
+        event: {
+            details: result.deliveryIntentId
+                ? `delivery queued for retry as ${result.deliveryIntentId}`
+                : 'delivery queued for retry',
+            type: 'capture.replied',
+        },
+        kind: 'deferred',
+        stopScanning: false,
+        summary: createAssistantAutoReplyOutcomeSummary({
+            replied: 1,
+        }),
+    };
+}
+function createSuccessfulReplyGroupOutcome(result) {
+    const delivery = result.delivery;
+    if (!delivery) {
+        throw new Error('assistant auto-reply delivery was missing after delivery confirmation');
+    }
+    return {
+        advanceCursor: true,
+        artifact: {
+            kind: 'result',
+            result,
+        },
+        event: {
+            details: `${delivery.channel} -> ${delivery.target}`,
+            type: 'capture.replied',
+        },
+        kind: 'replied',
+        stopScanning: false,
+        summary: createAssistantAutoReplyOutcomeSummary({
+            replied: 1,
+        }),
+    };
+}
+function createFailedGroupOutcome(input) {
+    const failure = describeAssistantAutoReplyFailure(input.error);
+    return {
+        advanceCursor: input.advanceCursor,
+        artifact: {
+            kind: 'error',
+            error: input.error,
+            failure,
+        },
+        event: {
+            details: failure.message,
+            errorCode: failure.code ?? undefined,
+            safeDetails: failure.safeSummary,
+            type: 'capture.reply-failed',
+        },
+        kind: 'failed',
+        stopScanning: input.stopScanning ?? false,
+        summary: createAssistantAutoReplyOutcomeSummary({
+            failed: 1,
+        }),
+    };
+}
+function createAssistantAutoReplyOutcomeSummary(input) {
+    return {
+        failed: input?.failed ?? 0,
+        replied: input?.replied ?? 0,
+        skipped: input?.skipped ?? 0,
+    };
+}
+async function evaluateAssistantAutoReplyGroup(input) {
+    if (!input.enabledChannels.includes(input.group.firstItem.summary.source)) {
+        return createAdvancingSkipDecision('channel not enabled for assistant auto-reply');
+    }
+    if (input.group.firstItem.summary.actorIsSelf && !input.allowSelfAuthored) {
+        return createAdvancingSkipDecision('capture is self-authored');
+    }
+    const existingGroupOutcome = await assistantAutoReplyGroupOutcomeArtifactExists(input.vault, input.group.firstCaptureId);
+    const existingArtifact = await Promise.all(input.group.captureIds.map((captureId) => assistantChatReplyArtifactExists(input.vault, captureId)));
+    const existingArtifactStatus = classifyAssistantAutoReplyGroupArtifactStatus(existingArtifact);
+    if (existingGroupOutcome) {
+        if (existingArtifactStatus === 'partial') {
+            return createDeferredSkipDecision('assistant reply artifacts are incomplete; will retry this capture after reply artifacts are rebuilt.');
+        }
+        return createAdvancingSkipDecision('assistant reply already handled');
+    }
+    if (existingArtifactStatus === 'complete') {
+        return createAdvancingSkipDecision('assistant reply already exists');
+    }
+    if (existingArtifactStatus === 'partial') {
+        return createDeferredSkipDecision('assistant reply artifacts are incomplete; will retry this capture after reply artifacts are rebuilt.');
+    }
+    const shownGroup = await loadAssistantAutoReplyCaptures({
+        group: input.group,
+        inboxServices: input.inboxServices,
+        requestId: input.requestId,
+        vault: input.vault,
+    });
+    const primaryCapture = shownGroup[0]?.capture;
+    if (!primaryCapture) {
+        return { kind: 'ignore' };
+    }
+    if (await assistantAutoReplyHandledByTurnReceipt(input.vault, input.group.captureIds)) {
+        return createAdvancingSkipDecision('assistant reply already handled');
+    }
+    const channelAdapter = getAssistantChannelAdapter(primaryCapture.source);
+    const autoReplySkipReason = channelAdapter?.canAutoReply(primaryCapture) ?? null;
+    if (autoReplySkipReason) {
+        return createAdvancingSkipDecision(autoReplySkipReason);
+    }
+    const preparedInput = await prepareAssistantAutoReplyInput(shownGroup, input.vault);
+    if (preparedInput.kind === 'defer') {
+        return createDeferredSkipDecision(preparedInput.reason);
+    }
+    if (preparedInput.kind === 'skip') {
+        return createAdvancingSkipDecision(preparedInput.reason);
+    }
+    let providerOverride = null;
+    if (preparedInput.requiresRichUserMessageContent) {
+        const richRoute = await resolveAutoReplyRichContentRoute({
+            capture: primaryCapture,
+            prompt: preparedInput.prompt,
+            userMessageContent: preparedInput.userMessageContent,
+            vault: input.vault,
+        });
+        if (!richRoute.supported) {
+            return createAdvancingSkipDecision('capture has image/PDF evidence but the configured assistant provider only accepts text input');
+        }
+        providerOverride = richRoute.providerOverride;
+    }
+    if (input.group.firstItem.summary.actorIsSelf &&
+        (await isRecentSelfAuthoredAssistantEcho({
+            vault: input.vault,
+            capture: primaryCapture,
+        }))) {
+        return createAdvancingSkipDecision('capture matches a recent assistant delivery');
+    }
+    return {
+        deliveryReplyToMessageId: readAutoReplyDeliveryReplyToMessageId(shownGroup),
+        kind: 'reply',
+        operatorAuthority: resolveAcceptedInboundMessageOperatorAuthority(),
+        primaryCapture,
+        prompt: preparedInput.prompt,
+        providerOverride,
+        userMessageContent: preparedInput.userMessageContent,
+    };
+}
+async function loadAssistantAutoReplyCaptures(input) {
+    return Promise.all(input.group.items.map(async (item) => ({
+        capture: (await input.inboxServices.show({
+            vault: input.vault,
+            requestId: input.requestId,
+            captureId: item.summary.captureId,
+        })).capture,
+        telegramMetadata: item.telegramMetadata,
+    })));
+}
+async function executeAssistantAutoReply(input) {
+    const watchdog = createAssistantProviderWatchdog(input);
+    try {
+        const result = await sendAssistantMessage({
+            vault: input.vault,
+            conversation: conversationRefFromCapture(input.primaryCapture),
+            abortSignal: watchdog.signal,
+            executionContext: input.executionContext,
+            operatorAuthority: input.operatorAuthority,
+            persistUserPromptOnFailure: false,
+            prompt: input.prompt,
+            ...(input.providerOverride ?? {}),
+            userMessageContent: input.userMessageContent,
+            includeFirstTurnCheckIn: true,
+            deliverResponse: true,
+            deliveryDispatchMode: input.deliveryDispatchMode,
+            deliveryReplyToMessageId: input.deliveryReplyToMessageId,
+            receiptMetadata: {
+                [AUTO_REPLY_RECEIPT_CAPTURE_ID_KEY]: input.replyCaptureId,
+                [AUTO_REPLY_RECEIPT_CAPTURE_IDS_KEY]: input.captureIds.join(','),
+            },
+            turnTrigger: 'automation-auto-reply',
+            maxSessionAgeMs: input.maxSessionAgeMs,
+            onProviderEvent: watchdog.onProviderEvent,
+        });
+        return resolveAssistantAutoReplySendResult({
+            onEvent: input.onEvent,
+            replyCaptureId: input.replyCaptureId,
+            result,
+        });
+    }
+    catch (error) {
+        throw watchdog.normalizeError(error);
+    }
+    finally {
+        watchdog.dispose();
+    }
+}
+function readAutoReplyDeliveryReplyToMessageId(captures) {
+    const primaryCapture = captures[0]?.capture;
+    if (!primaryCapture) {
+        return null;
+    }
+    if (primaryCapture.source === 'linq') {
+        return readLinqReplyToMessageId(primaryCapture);
+    }
+    if (primaryCapture.source !== 'telegram') {
+        return null;
+    }
+    for (let index = captures.length - 1; index >= 0; index -= 1) {
+        const messageId = normalizeNullableString(captures[index]?.telegramMetadata?.messageId);
+        if (messageId) {
+            return messageId;
+        }
+    }
+    return null;
+}
+function readLinqReplyToMessageId(capture) {
+    if (capture.source !== 'linq') {
+        return null;
+    }
+    const externalId = normalizeNullableString(capture.externalId);
+    if (!externalId?.startsWith('linq:')) {
+        return null;
+    }
+    return normalizeNullableString(externalId.slice('linq:'.length));
+}
+function resolveAssistantAutoReplySendResult(input) {
+    if (input.result.deliveryDeferred) {
+        input.onEvent?.({
+            type: 'capture.reply-progress',
+            captureId: input.replyCaptureId,
+            details: input.result.deliveryIntentId
+                ? `assistant queued outbound delivery for retry as ${input.result.deliveryIntentId}`
+                : 'assistant queued outbound delivery for retry',
+            providerKind: 'status',
+            providerState: 'completed',
+        });
+        return input.result;
+    }
+    if (input.result.deliveryError || input.result.delivery === null) {
+        const error = new Error(input.result.deliveryError?.message ??
+            'assistant generated a response, but the outbound delivery channel did not confirm the send');
+        if (input.result.deliveryIntentId) {
+            Object.defineProperty(error, 'outboxIntentId', {
+                configurable: true,
+                enumerable: false,
+                value: input.result.deliveryIntentId,
+                writable: true,
+            });
+        }
+        throw error;
+    }
+    return input.result;
+}
+function classifyAssistantAutoReplyFailure(input) {
+    if (isAssistantProviderStalledError(input.error)) {
+        return createDeferredGroupOutcome({
+            captureCount: input.captureCount,
+            reason: AUTO_REPLY_PROVIDER_STALLED_DETAIL,
+            stopScanning: true,
+        });
+    }
+    const detail = errorMessage(input.error);
+    if (isAssistantProviderConnectionLostError(input.error)) {
+        return createDeferredGroupOutcome({
+            captureCount: input.captureCount,
+            reason: `${detail} Will retry this capture after the provider reconnects.`,
+            stopScanning: true,
+        });
+    }
+    if (isAssistantProviderCapacityError(input.error)) {
+        return createFailedGroupOutcome({
+            advanceCursor: false,
+            error: input.error,
+            stopScanning: true,
+        });
+    }
+    return createFailedGroupOutcome({
+        advanceCursor: true,
+        error: input.error,
+    });
+}
+function isAssistantProviderCapacityError(error) {
+    const message = errorMessage(error).toLowerCase();
+    const code = error &&
+        typeof error === 'object' &&
+        'code' in error &&
+        typeof error.code === 'string'
+        ? error.code.toUpperCase()
+        : '';
+    const providerFailure = code.startsWith('ASSISTANT_') ||
+        message.includes('codex cli failed') ||
+        message.includes('assistant provider');
+    return providerFailure && (code.includes('RATE') ||
+        code.includes('LIMIT') ||
+        code.includes('QUOTA') ||
+        message.includes('rate limit') ||
+        message.includes('usage limit') ||
+        message.includes('quota') ||
+        message.includes('too many requests') ||
+        message.includes('purchase more credits') ||
+        message.includes('try again at '));
+}
+function classifyAssistantAutoReplyGroupArtifactStatus(artifacts) {
+    if (artifacts.every(Boolean)) {
+        return 'complete';
+    }
+    if (artifacts.some(Boolean)) {
+        return 'partial';
+    }
+    return 'none';
+}
+function createAdvancingSkipDecision(reason) {
+    return {
+        advanceCursor: true,
+        kind: 'skip',
+        reason,
+        stopScanning: false,
+    };
+}
+async function assistantAutoReplyHandledByTurnReceipt(vault, captureIds) {
+    const primaryCaptureId = captureIds[0];
+    if (!primaryCaptureId) {
+        return false;
+    }
+    const recentReceipts = await listAssistantTurnReceipts(vault, 200);
+    return recentReceipts.some((receipt) => {
+        if (!(receipt.status === 'completed' || receipt.status === 'deferred')) {
+            return false;
+        }
+        const startedEvent = receipt.timeline.find((event) => event.kind === 'turn.started');
+        if (!startedEvent) {
+            return false;
+        }
+        if (startedEvent.metadata[AUTO_REPLY_RECEIPT_CAPTURE_ID_KEY] === primaryCaptureId) {
+            return true;
+        }
+        const groupedCaptureIds = startedEvent.metadata[AUTO_REPLY_RECEIPT_CAPTURE_IDS_KEY]
+            ?.split(',')
+            .map((value) => value.trim())
+            .filter((value) => value.length > 0);
+        return groupedCaptureIds?.includes(primaryCaptureId) ?? false;
+    });
+}
+function createDeferredSkipDecision(reason) {
+    return {
+        advanceCursor: false,
+        kind: 'skip',
+        reason,
+        stopScanning: true,
+    };
+}
+async function isRecentSelfAuthoredAssistantEcho(input) {
+    const captureText = normalizeNullableString(input.capture.text);
+    if (!captureText) {
+        return false;
+    }
+    let resolved;
+    try {
+        resolved = await resolveAssistantSession({
+            vault: input.vault,
+            createIfMissing: false,
+            conversation: conversationRefFromCapture(input.capture),
+        });
+    }
+    catch (error) {
+        const code = error &&
+            typeof error === 'object' &&
+            'code' in error &&
+            typeof error.code === 'string'
+            ? error.code
+            : null;
+        if (code === 'ASSISTANT_SESSION_NOT_FOUND') {
+            return false;
+        }
+        throw error;
+    }
+    const referenceTimestamp = normalizeNullableString(resolved.session.lastTurnAt) ??
+        normalizeNullableString(resolved.session.updatedAt) ??
+        normalizeNullableString(resolved.session.createdAt);
+    if (!referenceTimestamp) {
+        return false;
+    }
+    const referenceTime = Date.parse(referenceTimestamp);
+    const captureTime = Date.parse(input.capture.occurredAt);
+    if (!Number.isFinite(referenceTime) || !Number.isFinite(captureTime)) {
+        return false;
+    }
+    if (captureTime < referenceTime ||
+        captureTime - referenceTime > SELF_AUTHORED_ECHO_WINDOW_MS) {
+        return false;
+    }
+    const transcript = await listAssistantTranscriptEntries(input.vault, resolved.session.sessionId);
+    const lastAssistantEntry = [...transcript]
+        .reverse()
+        .find((entry) => entry.kind === 'assistant');
+    if (!lastAssistantEntry) {
+        return false;
+    }
+    return (normalizeComparableText(lastAssistantEntry.text) ===
+        normalizeComparableText(captureText));
+}
+function normalizeComparableText(text) {
+    return text.replace(/\s+/gu, ' ').trim();
+}
+async function resolveAutoReplyRichContentRoute(input) {
+    const defaults = await resolveAssistantOperatorDefaults();
+    const messageInput = {
+        conversation: conversationRefFromCapture(input.capture),
+        prompt: input.prompt,
+        userMessageContent: input.userMessageContent,
+        vault: input.vault,
+    };
+    const routes = await resolveAssistantTurnRoutesForMessage(messageInput, defaults, createDefaultLocalAssistantModelTarget());
+    return selectAutoReplyRichContentRouteOverride(routes);
+}
+function selectAutoReplyRichContentRouteOverride(routes) {
+    const richRoute = selectAssistantTurnRouteOverride(routes, (route) => resolveAssistantProviderCapabilities(route.provider ?? 'codex-cli')
+        .supportsRichUserMessageContent);
+    if (!richRoute.route) {
+        return {
+            providerOverride: null,
+            supported: false,
+        };
+    }
+    return {
+        providerOverride: richRoute.providerOverride,
+        supported: true,
+    };
+}
+//# sourceMappingURL=reply.js.map