@clowder-ai/connector-feishu 0.0.0-stage → 0.1.0-alpha.8

package/dist/inbound-media-source.js

@@ -0,0 +1,111 @@
+import { createHash } from 'node:crypto';
+const STATE_PREFIX = 'media-source/';
+const stateKey = (reference) => `${STATE_PREFIX}${reference}`;
+const DEFINITIVE_SEND_REJECTION_CODES = new Set([
+    'VALIDATION', 'PERMISSION',
+]);
+function isLocator(value) {
+    if (value === null || typeof value !== 'object' || Array.isArray(value))
+        return false;
+    const candidate = value;
+    return typeof candidate.sourceEventId === 'string'
+        && ['image', 'file', 'audio', 'video'].includes(String(candidate.type))
+        && typeof candidate.platformKey === 'string';
+}
+function sameLocator(left, right) {
+    return left.sourceEventId === right.sourceEventId
+        && left.type === right.type
+        && left.platformKey === right.platformKey
+        && left.fileName === right.fileName
+        && left.duration === right.duration;
+}
+export function privateMediaReference(connectorId, sourceEventId, elementId) {
+    const digest = createHash('sha256').update(`${connectorId}\\0${sourceEventId}\\0${elementId}`).digest('hex');
+    return `pmr_${connectorId}_${digest}`;
+}
+export async function retainInboundMedia(context, connectorId, sourceId, sourceEventId, attachments) {
+    const retained = [];
+    try {
+        const elements = [];
+        for (const [index, attachment] of attachments.entries()) {
+            const elementId = `media-${index + 1}`;
+            const reference = privateMediaReference(connectorId, sourceEventId, elementId);
+            const locator = { sourceEventId, ...attachment };
+            const inserted = await context.storage.compareAndSet(stateKey(reference), null, locator);
+            if (inserted.applied) {
+                if (typeof inserted.revision !== 'number') {
+                    throw new Error('Inbound media state did not return a revision fence');
+                }
+                retained.push({ reference, revision: inserted.revision });
+            }
+            else {
+                const existing = await context.storage.get(stateKey(reference));
+                if (existing === undefined || !isLocator(existing.value) || !sameLocator(existing.value, locator)) {
+                    throw new Error('Inbound media reference conflicts with retained locator');
+                }
+            }
+            elements.push({
+                elementId,
+                kind: 'media_ref',
+                payload: {
+                    type: attachment.type, reference, sourceId,
+                    ...(attachment.fileName === undefined ? {} : { fileName: attachment.fileName }),
+                    ...(attachment.duration === undefined ? {} : { duration: attachment.duration }),
+                },
+            });
+        }
+        return { elements, ownership: { entries: retained } };
+    }
+    catch (error) {
+        const cleanup = await Promise.allSettled(retained.map(({ reference, revision }) => (context.storage.delete(stateKey(reference), revision))));
+        context.log('warn', 'Inbound media locator retention failed', {
+            connectorId,
+            sourceEventId,
+            attachmentCount: attachments.length,
+            cleanupFailed: cleanup.some(result => result.status === 'rejected'),
+            errorName: error instanceof Error ? error.name : 'unknown',
+        });
+        return {
+            elements: attachments.map((attachment, index) => ({
+                elementId: `media-${index + 1}`,
+                kind: 'media_unavailable',
+                payload: {
+                    type: attachment.type,
+                    reason: 'unavailable',
+                    ...(attachment.fileName === undefined ? {} : { fileName: attachment.fileName }),
+                },
+            })),
+            ownership: { entries: [] },
+        };
+    }
+}
+export async function releaseInboundMedia(context, ownership, sendError) {
+    if (sendError !== undefined) {
+        const code = sendError !== null && typeof sendError === 'object'
+            ? sendError.code
+            : undefined;
+        if (typeof code !== 'string' || !DEFINITIVE_SEND_REJECTION_CODES.has(code))
+            return;
+    }
+    await Promise.all(ownership.entries.map(({ reference, revision }) => (context.storage.delete(stateKey(reference), revision))));
+}
+export function createInboundMediaSource(context, download) {
+    return { read(reference, options = {}) {
+            return { async *[Symbol.asyncIterator]() {
+                    options.signal?.throwIfAborted();
+                    const entry = await context.storage.get(stateKey(reference));
+                    if (!entry || !isLocator(entry.value))
+                        throw new Error('plugin stream source is unavailable');
+                    const bytes = await download(entry.value);
+                    options.signal?.throwIfAborted();
+                    // Provider adapters retain their existing bounded download checks. No base64 materialization.
+                    for (let offset = 0; offset < bytes.length; offset += 524288) {
+                        options.signal?.throwIfAborted();
+                        // A retained iterator cannot outlive its current feature client.
+                        await context.storage.get(stateKey(reference));
+                        yield bytes.subarray(offset, Math.min(offset + 524288, bytes.length));
+                    }
+                } };
+        } };
+}
+//# sourceMappingURL=inbound-media-source.js.map

package/dist/inbound-media-source.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"inbound-media-source.js","sourceRoot":"","sources":["../src/inbound-media-source.ts"],"names":[],"mappings":"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"}

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export { FeishuAdapter, inferFeishuFileType } from './FeishuAdapter.js';
+export type { FeishuAdapterOptions, FeishuAttachment, FeishuCardAction, FeishuInboundMessage, FeishuMediaPayload, FeishuMentionAlias, } from './FeishuAdapter.js';
+export { FeishuTokenManager } from './FeishuTokenManager.js';
+export type { FeishuTokenManagerOptions } from './FeishuTokenManager.js';
+export { DefaultFeishuQrBindClient } from './FeishuQrBindClient.js';
+export type { FeishuQrBindClient, FeishuQrCreateResult, FeishuQrPollResult } from './FeishuQrBindClient.js';
+export { formatFeishuCard } from './feishu-card-formatter.js';
+export type { ConnectorLogger, MessageEnvelope, RichBlock } from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AACxE,YAAY,EACV,oBAAoB,EACpB,gBAAgB,EAChB,gBAAgB,EAChB,oBAAoB,EACpB,kBAAkB,EAClB,kBAAkB,GACnB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAC7D,YAAY,EAAE,yBAAyB,EAAE,MAAM,yBAAyB,CAAC;AACzE,OAAO,EAAE,yBAAyB,EAAE,MAAM,yBAAyB,CAAC;AACpE,YAAY,EAAE,kBAAkB,EAAE,oBAAoB,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAC5G,OAAO,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AAC9D,YAAY,EAAE,eAAe,EAAE,eAAe,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC"}

package/dist/index.js

@@ -0,0 +1,5 @@
+export { FeishuAdapter, inferFeishuFileType } from './FeishuAdapter.js';
+export { FeishuTokenManager } from './FeishuTokenManager.js';
+export { DefaultFeishuQrBindClient } from './FeishuQrBindClient.js';
+export { formatFeishuCard } from './feishu-card-formatter.js';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AASxE,OAAO,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAE7D,OAAO,EAAE,yBAAyB,EAAE,MAAM,yBAAyB,CAAC;AAEpE,OAAO,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAC"}

package/dist/lifecycle-action.d.ts

@@ -0,0 +1,30 @@
+import { type LifecycleAction } from './execution-status.js';
+import { type FeatureContext } from '@clowder-ai/plugin-sdk';
+type LifecycleEvent = Parameters<LifecycleAction>[0];
+type SettledEvent = Extract<LifecycleEvent, {
+    readonly state: 'settled';
+}>;
+export interface ConnectorLifecycleCallbacks {
+    sendPlaceholder(externalConversationId: string, text: string): Promise<string>;
+    editPlaceholder(externalConversationId: string, platformMessageId: string, text: string, phase: 'catching_up' | 'blocked', executionId: string): Promise<boolean>;
+    sendRecovery(externalConversationId: string, text: string): Promise<void>;
+    /** Resolve the sender display name recorded for a Host message id; only connectors with a reply-sender mapping implement this. */
+    resolveReplySenderName?(replyTo: string): Promise<string | undefined>;
+    onPlaceholder?(externalConversationId: string, platformMessageId: string, executionId: string): void | Promise<void>;
+    settle(input: {
+        readonly externalConversationId: string;
+        readonly platformMessageId?: string;
+        readonly actorDisplayName: string;
+        readonly recoveryText?: string;
+        readonly event: SettledEvent;
+    }): Promise<void>;
+}
+export declare function createConnectorLifecycleAction(context: FeatureContext, callbacks: ConnectorLifecycleCallbacks): ((input: unknown) => Promise<{
+    readonly deliveryId: string;
+} | {
+    readonly deliveryId: string;
+}>) & {
+    sweepNow: () => Promise<void>;
+};
+export {};
+//# sourceMappingURL=lifecycle-action.d.ts.map

package/dist/lifecycle-action.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lifecycle-action.d.ts","sourceRoot":"","sources":["../src/lifecycle-action.ts"],"names":[],"mappings":"AAAA,OAAO,EAAuE,KAAK,eAAe,EAAC,MAAM,uBAAuB,CAAC;AAEjI,OAAO,EACL,KAAK,cAAc,EACpB,MAAM,wBAAwB,CAAC;AAEhC,KAAK,cAAc,GAAG,UAAU,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC,CAAC;AACrD,KAAK,YAAY,GAAG,OAAO,CAAC,cAAc,EAAE;IAAE,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAA;CAAE,CAAC,CAAC;AAE3E,MAAM,WAAW,2BAA2B;IAC1C,eAAe,CAAC,sBAAsB,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IAC/E,eAAe,CACb,sBAAsB,EAAE,MAAM,EAC9B,iBAAiB,EAAE,MAAM,EACzB,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,aAAa,GAAG,SAAS,EAChC,WAAW,EAAE,MAAM,GAClB,OAAO,CAAC,OAAO,CAAC,CAAC;IACpB,YAAY,CAAC,sBAAsB,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC1E,kIAAkI;IAClI,sBAAsB,CAAC,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAAC;IACtE,aAAa,CAAC,CACZ,sBAAsB,EAAE,MAAM,EAC9B,iBAAiB,EAAE,MAAM,EACzB,WAAW,EAAE,MAAM,GAClB,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACxB,MAAM,CAAC,KAAK,EAAE;QACZ,QAAQ,CAAC,sBAAsB,EAAE,MAAM,CAAC;QACxC,QAAQ,CAAC,iBAAiB,CAAC,EAAE,MAAM,CAAC;QACpC,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;QAClC,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;QAC/B,QAAQ,CAAC,KAAK,EAAE,YAAY,CAAC;KAC9B,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACnB;AAuFD,wBAAgB,8BAA8B,CAC5C,OAAO,EAAE,cAAc,EACvB,SAAS,EAAE,2BAA2B;;;;;oBAMd,OAAO,CAAC,IAAI,CAAC;EAgctC"}

package/dist/lifecycle-action.js

@@ -0,0 +1,457 @@
+import { decideLifecycleTransition, defineLifecycleAction, lifecycleRejectReason } from './execution-status.js';
+import { threadMappings } from './thread-mappings.js';
+const STARTED_TEXT = '🤔 思考中...';
+const CATCHING_UP_TEXT = '🔄 收到新消息，正在重新整理回复…';
+const LIFECYCLE_KEY_PREFIX = 'lifecycle/';
+// A settled tombstone only answers Host redeliveries with replay/reject; a
+// day is far beyond any sane redelivery horizon, so keeping it longer only
+// accumulates dead keys.
+const LIFECYCLE_TOMBSTONE_TTL_MS = 24 * 60 * 60 * 1000;
+// Records that never settled are Host-crash orphans: their placeholder text
+// is already terminal. The TTL must exceed the longest legitimate in-flight
+// turn (cat work can span many hours), so 24h bounds orphans without
+// deleting lifecycles that are still actively running.
+const LIFECYCLE_STRANDED_TTL_MS = 24 * 60 * 60 * 1000;
+const SWEEP_EVERY_WRITES = 25;
+function object(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+function isPendingEffect(value) {
+    return object(value)
+        && value.v === 1
+        && (value.state === 'blocked' || value.state === 'settled')
+        && typeof value.recoveryText === 'string';
+}
+function lifecycleError(code, message) {
+    return Object.assign(new Error(message), { code });
+}
+function storedLifecycle(value) {
+    if (!object(value)
+        || (value.version !== 1 && value.version !== 2)
+        || !Array.isArray(value.history)
+        || typeof value.actorDisplayName !== 'string'
+        || (value.platformMessageId !== undefined && typeof value.platformMessageId !== 'string')
+        || (value.platformMessageByKey !== undefined
+            && (!object(value.platformMessageByKey) || Object.values(value.platformMessageByKey).some(id => typeof id !== 'string')))
+        || (value.updatedAt !== undefined && typeof value.updatedAt !== 'number')
+        || (value.tombstone !== undefined && typeof value.tombstone !== 'boolean')
+        || (value.deliveryIds !== undefined && (!Array.isArray(value.deliveryIds) || value.deliveryIds.some(id => typeof id !== 'string')))
+        || (value.settledAt !== undefined && typeof value.settledAt !== 'number')
+        || (value.pendingEffect !== undefined && !isPendingEffect(value.pendingEffect))) {
+        throw lifecycleError('PLUGIN_INTERNAL', 'stored lifecycle state is invalid');
+    }
+    return structuredClone(value);
+}
+function recoveryText(event) {
+    return `⚠️ 未能完成最新消息重读（${event.reason}）。请打开 Clowder AI 重试${event.recoveryUrl ? `：${event.recoveryUrl}` : '。'}`;
+}
+export function createConnectorLifecycleAction(context, callbacks) {
+    const tails = new Map();
+    let writesSinceSweep = 0;
+    let sweepInFlight = false;
+    const sweep = async () => {
+        let listed;
+        try {
+            listed = await context.storage.list();
+        }
+        catch (error) {
+            context.log('warn', 'Connector lifecycle sweep failed', {
+                errorName: error instanceof Error ? error.name : 'unknown',
+            });
+            return;
+        }
+        const now = Date.now();
+        for (const [key, item] of Object.entries(listed)) {
+            if (!key.startsWith(LIFECYCLE_KEY_PREFIX))
+                continue;
+            let record;
+            try {
+                record = storedLifecycle(item?.value);
+            }
+            catch {
+                continue;
+            }
+            if (record.tombstone === true) {
+                const settledAt = record.settledAt ?? record.updatedAt;
+                if (settledAt !== undefined && settledAt + LIFECYCLE_TOMBSTONE_TTL_MS < now) {
+                    await context.storage.delete(key, item.revision).catch(() => undefined);
+                }
+                continue;
+            }
+            // v1 records carry no updatedAt, so their age is unknown; the v2 write
+            // path re-binds them with a timestamp on the next transition.
+            if (record.updatedAt !== undefined && record.updatedAt + LIFECYCLE_STRANDED_TTL_MS < now) {
+                await context.storage.delete(key, item.revision).catch(() => undefined);
+            }
+        }
+    };
+    // Single-flight background sweep, mirroring reply-sender-map: the hot path
+    // only counts writes. console.warn (not context.log) is deliberate here —
+    // log() throws FeatureContextRevokedError after feature shutdown, which
+    // would turn this last-resort guard into an unhandled rejection.
+    const sweepInBackground = () => {
+        if (sweepInFlight)
+            return;
+        sweepInFlight = true;
+        void sweep()
+            .catch((error) => {
+            console.warn('Connector lifecycle sweep failed', {
+                errorName: error instanceof Error ? error.name : 'unknown',
+            });
+        })
+            .finally(() => {
+            sweepInFlight = false;
+        });
+    };
+    const countWrite = () => {
+        writesSinceSweep += 1;
+        if (writesSinceSweep < SWEEP_EVERY_WRITES)
+            return;
+        writesSinceSweep = 0;
+        sweepInBackground();
+    };
+    // Platform effects must not fail the action; the write-ahead record already
+    // accepted the event, so a throwing callback is logged and skipped.
+    const runEffectSafely = async (executionId, state, label, effect) => {
+        try {
+            await effect();
+            return true;
+        }
+        catch (error) {
+            context.log('warn', `Connector lifecycle ${label} failed`, {
+                executionId,
+                state,
+                errorName: error instanceof Error ? error.name : 'unknown',
+            });
+            return false;
+        }
+    };
+    // Binding listing feeds every side-effect path; a failure here must
+    // surface as a coded lifecycle error, not a bare storage/transport
+    // exception escaping the action boundary.
+    const listThreadBindings = async (threadId) => {
+        let listed;
+        try {
+            listed = await threadMappings(context).listBindings();
+        }
+        catch (error) {
+            throw lifecycleError('PLUGIN_INTERNAL', `lifecycle thread ${threadId} binding listing failed: ${error instanceof Error ? error.message : 'unknown'}`);
+        }
+        return listed.filter(candidate => candidate.threadId === threadId);
+    };
+    // A redelivery (or a later transition arriving first) can find a record
+    // whose accepted side effect never ran because the process died between the
+    // pre-write and the platform call. Re-run exactly that effect through the
+    // same callbacks and per-binding fallbacks as the original path.
+    //
+    // The marker is cleared after the ATTEMPT, not after confirmed success:
+    // runEffectSafely swallows per-binding failures (they are logged), and an
+    // unbounded "retry until applied" loop would duplicate-send on every
+    // redelivery. One bounded re-execution per redelivery beats both a lost
+    // recovery hint and an effect storm.
+    //
+    // Returns whether the effect was actually attempted on at least one
+    // binding. A thread with no matching binding is not an attempt: the caller
+    // must keep the marker so a redelivery after the binding returns can still
+    // recover the hint.
+    const reexecutePendingEffect = async (stored) => {
+        const pending = stored.pendingEffect;
+        if (pending === undefined)
+            return false;
+        const sourceEvent = [...stored.history].reverse().find((candidate) => (candidate.state === pending.state));
+        if (sourceEvent === undefined)
+            return false;
+        const bindings = await listThreadBindings(sourceEvent.threadId);
+        // Legacy records carry a single platformMessageId; with exactly one
+        // matching binding it can only have belonged to that binding.
+        let messageIds = { ...(stored.platformMessageByKey ?? {}) };
+        if (Object.keys(messageIds).length === 0 && bindings.length === 1 && stored.platformMessageId !== undefined) {
+            messageIds = { [bindings[0].key]: stored.platformMessageId };
+        }
+        for (const binding of bindings) {
+            const platformMessageId = messageIds[binding.key];
+            if (pending.state === 'blocked') {
+                const edited = platformMessageId !== undefined && await runEffectSafely(sourceEvent.executionId, 'blocked', 'blocked edit', async () => {
+                    const applied = await callbacks.editPlaceholder(binding.key, platformMessageId, pending.recoveryText, 'blocked', sourceEvent.executionId);
+                    if (!applied)
+                        throw new Error('placeholder is no longer editable');
+                });
+                if (!edited) {
+                    await runEffectSafely(sourceEvent.executionId, 'blocked', 'blocked recovery send', () => callbacks.sendRecovery(binding.key, pending.recoveryText));
+                }
+            }
+            else {
+                await runEffectSafely(sourceEvent.executionId, 'settled', 'settlement', () => callbacks.settle({
+                    externalConversationId: binding.key,
+                    ...(platformMessageId === undefined ? {} : { platformMessageId }),
+                    actorDisplayName: stored.actorDisplayName,
+                    recoveryText: pending.recoveryText,
+                    event: sourceEvent,
+                }));
+            }
+        }
+        return bindings.length > 0;
+    };
+    const clearPendingEffect = async (stateKey, stored) => {
+        try {
+            await context.storage.set(stateKey, { ...stored, pendingEffect: undefined });
+            countWrite();
+        }
+        catch (error) {
+            // The marker survives, so a further redelivery re-executes the effect
+            // once more; losing the clear is duplicate-tolerant by design.
+            context.log('warn', 'Connector lifecycle pending-effect clear failed', {
+                errorName: error instanceof Error ? error.name : 'unknown',
+            });
+        }
+    };
+    const handle = async (event) => {
+        const stateKey = `lifecycle/${event.executionId}`;
+        const safely = (label, effect) => runEffectSafely(event.executionId, event.state, label, effect);
+        const entry = await context.storage.get(stateKey);
+        const stored = entry === undefined ? undefined : storedLifecycle(entry.value);
+        if (stored?.tombstone === true) {
+            // The tombstone keeps the full event history, so redelivery judgment is
+            // the same as the pre-settle path: an exact redelivery of anything the
+            // Host already acked answers replay, the same deliveryId with different
+            // content is a delivery conflict, and anything else is out of order.
+            const tombstoneDecision = decideLifecycleTransition(stored.history, event);
+            if (tombstoneDecision.kind === 'replay') {
+                // Crash residue: the accepted side effect may never have run. Re-run
+                // it once for this redelivery. The marker is cleared only when the
+                // effect was actually attempted: with no binding there is nothing to
+                // retry, and a later redelivery must still be able to recover the
+                // hint (see reexecutePendingEffect for why not after success).
+                if (stored.pendingEffect !== undefined && stored.pendingEffect.state === event.state) {
+                    if (await reexecutePendingEffect(stored)) {
+                        await clearPendingEffect(stateKey, stored);
+                    }
+                }
+                return { deliveryId: event.deliveryId };
+            }
+            if (tombstoneDecision.kind === 'reject' && tombstoneDecision.reason === 'DELIVERY_CONFLICT') {
+                throw lifecycleError(lifecycleRejectReason(tombstoneDecision), `lifecycle ${tombstoneDecision.reason.toLowerCase()}`);
+            }
+            // Tombstones written before the full history was retained only know the
+            // accepted deliveryId set; for them that set is the only replay identity.
+            const deliveryIds = stored.deliveryIds ?? [];
+            if (deliveryIds.includes(event.deliveryId)) {
+                return { deliveryId: event.deliveryId };
+            }
+            throw lifecycleError('EXECUTION_OUT_OF_ORDER', 'lifecycle is already settled');
+        }
+        const history = stored?.history ?? [];
+        const decision = decideLifecycleTransition(history, event);
+        if (decision.kind === 'replay') {
+            // Crash residue, pre-settle flavor: the blocked recovery effect was
+            // accepted but may never have run. Re-run it once. The marker is
+            // cleared only when the effect was actually attempted: with no binding
+            // a later redelivery must still be able to recover the hint.
+            if (stored?.pendingEffect !== undefined && stored.pendingEffect.state === event.state) {
+                if (await reexecutePendingEffect(stored)) {
+                    await clearPendingEffect(stateKey, stored);
+                }
+            }
+            return { deliveryId: event.deliveryId };
+        }
+        if (decision.kind === 'reject') {
+            throw lifecycleError(lifecycleRejectReason(decision), `lifecycle ${decision.reason.toLowerCase()}`);
+        }
+        // A new transition arrives while an older one still has an unconfirmed
+        // side effect (the crash window, or a lost post-write): this write would
+        // overwrite the marker, so flush the pending effect first and clear the
+        // marker. The marker is cleared only when the flush was actually
+        // attempted on at least one binding: with no binding the flush is a
+        // no-op and clearing here would lose the recovery hint for good once
+        // the zero-binding throw below rejects this delivery. Without the clear,
+        // a failed new pre-write would leave the old marker in place and every
+        // Host retry of this delivery would re-run the already-flushed effect
+        // again. An occasional duplicate beats a lost recovery hint.
+        if (stored?.pendingEffect !== undefined) {
+            if (await reexecutePendingEffect(stored)) {
+                await clearPendingEffect(stateKey, stored);
+            }
+        }
+        // One thread can carry several provider bindings (the Host allows
+        // rebinding different external chats onto the same thread), so every
+        // matching binding receives the outbound effects.
+        const bindings = await listThreadBindings(event.threadId);
+        if (bindings.length === 0) {
+            throw lifecycleError('PLUGIN_INTERNAL', `lifecycle thread ${event.threadId} has no provider binding`);
+        }
+        const actorDisplayName = event.state === 'started'
+            ? event.presentation.actor.displayName
+            : stored?.actorDisplayName ?? '';
+        // Per-binding placeholder message ids. Legacy records carry a single
+        // platformMessageId; with exactly one matching binding it can only have
+        // belonged to that binding.
+        let messageIds = { ...(stored?.platformMessageByKey ?? {}) };
+        if (Object.keys(messageIds).length === 0 && bindings.length === 1 && stored?.platformMessageId !== undefined) {
+            messageIds = { [bindings[0].key]: stored.platformMessageId };
+        }
+        // Recovery text is decided up front: the blocked transition's hint, or
+        // the retained blocked event's hint for a settled transition.
+        const blocked = history.slice(history.map(candidate => candidate.state).lastIndexOf('resumed') + 1).reverse().find((candidate) => (candidate.state === 'blocked'));
+        // Transitions carrying a user-facing recovery side effect are marked
+        // pending-effect in the pre-write; the post-write clears the marker once
+        // the effect completed. Started placeholders stay at-most-once on
+        // purpose — the final reply arrives separately — and catching_up edits
+        // self-heal through the later blocked/settle effects.
+        const pendingEffect = event.state === 'blocked'
+            ? { v: 1, state: 'blocked', recoveryText: recoveryText(event) }
+            : event.state === 'settled' && blocked !== undefined
+                ? { v: 1, state: 'settled', recoveryText: recoveryText(blocked) }
+                : undefined;
+        // Settled records compress into a tombstone: platform effects stop, but
+        // the full event history is retained so redelivery judgment can still
+        // distinguish an exact replay from a same-deliveryId content conflict.
+        const nextRecord = (ids, pending) => ({
+            version: 2,
+            history: [...history, event],
+            // Keep the legacy single-id field only when it is unambiguous.
+            ...(Object.keys(ids).length === 1 ? { platformMessageId: Object.values(ids)[0] } : {}),
+            ...(Object.keys(ids).length === 0 ? {} : { platformMessageByKey: ids }),
+            actorDisplayName,
+            updatedAt: Date.now(),
+            ...(pending !== undefined ? { pendingEffect: pending } : {}),
+            ...(event.state === 'settled'
+                ? { tombstone: true, deliveryIds: [...history.map(candidate => candidate.deliveryId), event.deliveryId], settledAt: Date.now() }
+                : {}),
+        });
+        // Write-ahead: persist the accepted event before any platform side
+        // effect, so a crash between effect and store cannot leave later events
+        // orphaned as OUT_OF_ORDER. The pre-write carries the pending-effect
+        // marker, so a redelivery that finds it re-runs the unconfirmed effect.
+        // If even the identical retry fails we throw before any side effect: no
+        // half-persisted record, no duplicate sends.
+        const preWrite = nextRecord(messageIds, pendingEffect);
+        try {
+            await context.storage.set(stateKey, preWrite);
+            countWrite();
+        }
+        catch {
+            try {
+                await context.storage.set(stateKey, preWrite);
+                countWrite();
+            }
+            catch (error) {
+                throw lifecycleError('PLUGIN_INTERNAL', `lifecycle ${event.executionId} state pre-write failed: ${error instanceof Error ? error.message : 'unknown'}`);
+            }
+        }
+        // Resolve the sender name once, outside the per-binding loop: it only
+        // depends on event.replyTo, never on the binding, so N bindings must not
+        // trigger N lookups. Resolve before the safely() wrapper: a throwing
+        // callback must not take down the whole placeholder send. resolve() in
+        // reply-sender-map already swallows storage errors; this catch covers
+        // every other failure reason.
+        let senderName;
+        if (event.state === 'started' && event.replyTo !== undefined && callbacks.resolveReplySenderName !== undefined) {
+            try {
+                senderName = await callbacks.resolveReplySenderName(event.replyTo);
+            }
+            catch (error) {
+                context.log('warn', 'Connector lifecycle sender name resolution failed', {
+                    executionId: event.executionId,
+                    errorName: error instanceof Error ? error.name : 'unknown',
+                });
+                senderName = undefined;
+            }
+        }
+        const senderSuffix = senderName ? `→${senderName}` : '';
+        for (const binding of bindings) {
+            let platformMessageId = messageIds[binding.key];
+            switch (event.state) {
+                case 'started':
+                    await safely('placeholder send', async () => {
+                        const displayName = actorDisplayName || '猫猫';
+                        const placeholderLine = event.placeholderLine ?? STARTED_TEXT;
+                        const candidate = await callbacks.sendPlaceholder(binding.key, `【${displayName}🐱${senderSuffix}】${placeholderLine}`);
+                        platformMessageId = candidate.length > 0 ? candidate : undefined;
+                        if (platformMessageId !== undefined) {
+                            await callbacks.onPlaceholder?.(binding.key, platformMessageId, event.executionId);
+                        }
+                    });
+                    break;
+                case 'resumed':
+                    await safely('resumed feedback', async () => {
+                        const text = `【${actorDisplayName || '猫猫'}🐱】${STARTED_TEXT}`;
+                        if (platformMessageId !== undefined && await callbacks.editPlaceholder(binding.key, platformMessageId, text, 'catching_up', event.executionId))
+                            return;
+                        const candidate = await callbacks.sendPlaceholder(binding.key, text);
+                        platformMessageId = candidate || undefined;
+                        if (platformMessageId)
+                            await callbacks.onPlaceholder?.(binding.key, platformMessageId, event.executionId);
+                    });
+                    break;
+                case 'catching_up':
+                    if (platformMessageId !== undefined) {
+                        await safely('catching-up edit', () => callbacks.editPlaceholder(binding.key, platformMessageId, CATCHING_UP_TEXT, 'catching_up', event.executionId));
+                    }
+                    break;
+                case 'blocked':
+                    {
+                        const text = recoveryText(event);
+                        const edited = platformMessageId !== undefined && await safely('blocked edit', async () => {
+                            const applied = await callbacks.editPlaceholder(binding.key, platformMessageId, text, 'blocked', event.executionId);
+                            if (!applied)
+                                throw new Error('placeholder is no longer editable');
+                        });
+                        if (!edited) {
+                            await safely('blocked recovery send', () => callbacks.sendRecovery(binding.key, text));
+                        }
+                    }
+                    break;
+                case 'settled': {
+                    await safely('settlement', () => callbacks.settle({
+                        externalConversationId: binding.key,
+                        ...(platformMessageId === undefined ? {} : { platformMessageId }),
+                        actorDisplayName,
+                        ...(blocked === undefined ? {} : { recoveryText: recoveryText(blocked) }),
+                        event,
+                    }));
+                    break;
+                }
+            }
+            if (platformMessageId === undefined)
+                delete messageIds[binding.key];
+            else
+                messageIds[binding.key] = platformMessageId;
+        }
+        try {
+            await context.storage.set(stateKey, nextRecord(messageIds));
+            countWrite();
+        }
+        catch (error) {
+            // Post-write failure is warn-only: the event already sits in history
+            // via the write-ahead, so a Host replay of this delivery is answered
+            // as replay and never re-runs the platform side effects. The recovery
+            // effect is the exception: its marker survives until a redelivery
+            // re-executes it, so a lost post-write there is duplicate-tolerant
+            // rather than losing the hint. The only other loss is the fresh
+            // platformMessageId, covered by the existing
+            // undefined-platformMessageId fallback for later edits.
+            context.log('warn', 'Connector lifecycle state post-write failed', {
+                executionId: event.executionId,
+                state: event.state,
+                errorName: error instanceof Error ? error.name : 'unknown',
+            });
+        }
+        return { deliveryId: event.deliveryId };
+    };
+    const action = defineLifecycleAction(async (event) => {
+        const previous = tails.get(event.executionId) ?? Promise.resolve();
+        const current = previous.catch(() => undefined).then(() => handle(event));
+        const tail = current.then(() => undefined, () => undefined);
+        tails.set(event.executionId, tail);
+        try {
+            return await current;
+        }
+        finally {
+            if (tails.get(event.executionId) === tail)
+                tails.delete(event.executionId);
+        }
+    });
+    // Test/debug hook: force the background sweep synchronously.
+    return Object.assign(action, { sweepNow: sweep });
+}
+//# sourceMappingURL=lifecycle-action.js.map