@dsh-enhanced/lark-channel 0.1.3

package/lib/adapter.js

@@ -0,0 +1,965 @@
+import { createHash } from 'node:crypto';
+import { LarkApprovalError, signLarkApprovalAction, verifyLarkApprovalAction, verifyLarkApprovalActionForRecovery, } from './approval.js';
+import { LarkModelPickerError, parseLarkModelPickerCallback, signLarkModelPickerAction, verifyLarkModelPickerAction, } from './model-picker.js';
+import { isLarkTopLevelSenderThread } from './group-thread.js';
+import { normalizeLarkMessage } from './normalize.js';
+import { LarkPermissionPickerError, parseLarkPermissionPickerCallback, signLarkPermissionPickerAction, verifyLarkPermissionPickerAction, } from './permission-picker.js';
+import { LarkProgressPresenter } from './progress.js';
+import { LARK_APPROVAL_CARD_MAX_BYTES, renderLarkMessage } from './sdk.js';
+import { LarkToolApprovalError, signLarkToolApprovalAction, verifyLarkToolApprovalAction, } from './tool-approval.js';
+import { LarkTransportError, } from './types.js';
+const LARK_TOOL_APPROVAL_REASON_MAX_BYTES = 2 * 1_024;
+const LARK_TOOL_APPROVAL_ARGUMENTS_MAX_BYTES = 16 * 1_024;
+const LARK_TOOL_APPROVAL_MAX_TIMER_MS = 2_147_483_647;
+const larkCallbackIdentifier = /^[A-Za-z0-9][A-Za-z0-9._@:-]{0,255}$/u;
+const larkProviderMessageIdentifier = /^[A-Za-z0-9][A-Za-z0-9._@/-]{0,255}$/u;
+function hasUsableApprovalSecret(secret) {
+    return secret !== undefined && Buffer.byteLength(secret, 'utf8') >= 16;
+}
+function boundedReviewText(value, maxBytes) {
+    return value === undefined || (Buffer.byteLength(value, 'utf8') <= maxBytes
+        && !/(?:\p{Cc}|\p{Bidi_Control})/u.test(value.replaceAll('\n', '').replaceAll('\r', '').replaceAll('\t', '')));
+}
+function sameToolApprovalPayload(left, right) {
+    return left.version === right.version
+        && left.channel === right.channel
+        && left.account === right.account
+        && left.tenant === right.tenant
+        && left.operationId === right.operationId
+        && left.bindingId === right.bindingId
+        && left.chatId === right.chatId
+        && left.ownerUser === right.ownerUser
+        && left.actionHash === right.actionHash
+        && left.toolName === right.toolName
+        && left.callId === right.callId
+        && left.expiresAt === right.expiresAt;
+}
+function failureCode(code) {
+    return `lark-${code.replaceAll('_', '-')}`;
+}
+function modelPickerFallbackText(intent) {
+    const picker = intent.modelPicker;
+    if (picker === undefined)
+        return intent.text;
+    return [
+        '飞书未接受模型选择卡片，已回退为文字目录。',
+        intent.text,
+        '',
+        '可用模型：',
+        ...picker.models.map(model => `- ${model.provider}/${model.id}${model.name === model.id ? '' : ` — ${model.name}`}`),
+        '',
+        '切换：/model use <provider/model>',
+        '恢复默认：/model reset',
+    ].join('\n');
+}
+function permissionPickerCard(intent, secret, capability) {
+    const current = intent.current === 'ask'
+        ? '请求批准（ask）'
+        : intent.current === 'auto'
+            ? '帮我批准（auto）'
+            : intent.current === 'full'
+                ? '完全访问权限（full）'
+                : '自定义安全组合（custom）';
+    const callbackValue = (level) => ({
+        permissionPicker: signLarkPermissionPickerAction(secret, {
+            version: 2,
+            ...capability,
+            operationId: intent.operationId,
+            bindingVersion: intent.bindingVersion,
+            sessionId: intent.sessionId,
+            issuedAt: intent.issuedAt,
+            expiresAt: intent.expiresAt,
+            expectedStateHash: intent.expectedStateHash,
+            emergencyStopVersion: intent.emergencyStopVersion,
+            level,
+        }),
+    });
+    return {
+        title: '选择权限模式',
+        body: `当前：${current}。请选择新档位。`,
+        current: intent.current,
+        callbackValues: {
+            ask: callbackValue('ask'),
+            auto: callbackValue('auto'),
+            full: callbackValue('full'),
+        },
+    };
+}
+function sendFailure(error) {
+    if (!(error instanceof LarkTransportError)) {
+        return { outcome: 'unknown', failureCode: 'lark-unknown' };
+    }
+    if (error.code === 'send_timeout' || error.code === 'unknown') {
+        return { outcome: 'unknown', failureCode: failureCode(error.code) };
+    }
+    const retryable = error.code === 'rate_limited' || error.code === 'not_connected';
+    return {
+        outcome: 'not-sent',
+        failureCode: failureCode(error.code),
+        retryable,
+        ...(error.retryAfterMs === undefined ? {} : { retryAfterMs: error.retryAfterMs }),
+    };
+}
+function routeParts(route) {
+    const separator = route.indexOf('/');
+    if (separator <= 0 || separator === route.length - 1)
+        return undefined;
+    return { provider: route.slice(0, separator), model: route.slice(separator + 1) };
+}
+function defaultEffortOption(effortIds) {
+    let value = '__default__';
+    while (effortIds.includes(value))
+        value += '_';
+    return value;
+}
+function resolveModelPicker(picker, preferred = {}) {
+    const modelsByProvider = new Map();
+    for (const model of picker.models) {
+        const models = modelsByProvider.get(model.provider) ?? [];
+        models.push(model);
+        modelsByProvider.set(model.provider, models);
+    }
+    const provider = [preferred.provider, picker.current.provider, ...picker.providers.map(value => value.id)]
+        .find(value => value !== undefined && (modelsByProvider.get(value)?.length ?? 0) > 0);
+    if (provider === undefined)
+        throw new LarkModelPickerError('invalid', 'model picker has no selectable provider');
+    const providerModels = modelsByProvider.get(provider);
+    const currentRoute = `${picker.current.provider}/${picker.current.model}`;
+    const route = [preferred.route, currentRoute]
+        .find(value => value !== undefined && providerModels.some(model => `${model.provider}/${model.id}` === value))
+        ?? `${providerModels[0].provider}/${providerModels[0].id}`;
+    const selectedModel = providerModels.find(model => `${model.provider}/${model.id}` === route);
+    const effortNames = new Map(picker.efforts.map(effort => [effort.id, effort.name]));
+    const linkedEfforts = (selectedModel.effortIds ?? [])
+        .flatMap(id => effortNames.has(id) ? [{ value: id, label: effortNames.get(id) }] : []);
+    const defaultEffort = defaultEffortOption(linkedEfforts.map(effort => effort.value));
+    const preferredEffort = preferred.effort;
+    const initialEffort = preferredEffort === null
+        ? defaultEffort
+        : preferredEffort !== undefined && linkedEfforts.some(effort => effort.value === preferredEffort)
+            ? preferredEffort
+            : route === currentRoute && picker.current.reasoningEffort !== undefined
+                && linkedEfforts.some(effort => effort.value === picker.current.reasoningEffort)
+                ? picker.current.reasoningEffort
+                : defaultEffort;
+    return { modelsByProvider, provider, providerModels, route, selectedModel,
+        linkedEfforts, defaultEffort, initialEffort };
+}
+function resolvedModelRoute(resolved) {
+    return { provider: resolved.provider, model: resolved.selectedModel.id,
+        ...(resolved.initialEffort === resolved.defaultEffort ? {} : { reasoningEffort: resolved.initialEffort }) };
+}
+function modelPickerCard(picker, secret, capability, preferred = {}) {
+    const { modelsByProvider, provider, providerModels, route, selectedModel, linkedEfforts, defaultEffort, initialEffort } = resolveModelPicker(picker, preferred);
+    const currentRoute = `${picker.current.provider}/${picker.current.model}`;
+    const signedState = {
+        version: 3,
+        ...capability,
+        provider,
+        model: selectedModel.id,
+        effort: initialEffort === defaultEffort ? null : initialEffort,
+    };
+    const callbackValue = (action) => ({
+        modelPicker: signLarkModelPickerAction(secret, { ...signedState, action }),
+    });
+    const currentEffort = picker.current.reasoningEffort === undefined ? '' : `，effort：${picker.current.reasoningEffort}`;
+    return {
+        title: '选择会话模型',
+        body: `当前模型：${currentRoute}${currentEffort}\n\n选择将在下一条消息生效，并保留当前上下文。`,
+        providerOptions: picker.providers
+            .filter(value => (modelsByProvider.get(value.id)?.length ?? 0) > 0)
+            .map(value => ({ value: value.id, label: value.name })),
+        modelOptions: providerModels.map(model => ({ value: `${model.provider}/${model.id}`, label: model.name })),
+        effortOptions: [
+            { value: defaultEffort, label: linkedEfforts.length === 0
+                    ? '默认（该模型无 effort 档位）'
+                    : '默认（由模型决定）' },
+            ...linkedEfforts,
+        ],
+        initialProvider: provider,
+        initialModel: route,
+        initialEffort,
+        callbackValues: {
+            provider: callbackValue('provider'),
+            model: callbackValue('model'),
+            effort: callbackValue('effort'),
+            confirm: callbackValue('confirm'),
+        },
+    };
+}
+function callbackCard(card) {
+    const rendered = renderLarkMessage({ modelPicker: card });
+    if (rendered.msgType !== 'interactive') {
+        throw new LarkModelPickerError('invalid', 'model picker callback did not render a card');
+    }
+    const value = JSON.parse(rendered.content);
+    if (value === null || typeof value !== 'object' || Array.isArray(value)) {
+        throw new LarkModelPickerError('invalid', 'model picker callback card is invalid');
+    }
+    return { card: { type: 'raw', data: value } };
+}
+export class LarkDeliveryAdapter {
+    config;
+    transport;
+    channel = 'lark';
+    account;
+    capabilities;
+    now;
+    approvalSecret;
+    settleApproval;
+    recoverApprovalSettlement;
+    settleModelSelection;
+    settlePermissionSelection;
+    loadModelPicker;
+    advanceModelPicker;
+    statusReactions;
+    progressPresenter;
+    pendingToolApprovals = new Map();
+    toolApprovalTombstones = new Map();
+    state = 'disconnected';
+    gapGeneration = 0;
+    lastErrorCode;
+    constructor(config, transport, options = {}) {
+        this.config = config;
+        this.transport = transport;
+        this.account = config.account;
+        const permissionPickerAvailable = hasUsableApprovalSecret(options.approvalSecret)
+            && options.settlePermissionSelection !== undefined;
+        this.capabilities = Object.freeze({
+            reconcileUnknownSend: false,
+            receipts: [],
+            formats: permissionPickerAvailable
+                ? ['plain', 'markdown', 'approval', 'model-picker', 'permission-picker']
+                : ['plain', 'markdown', 'approval', 'model-picker'],
+            inboundImages: typeof transport.downloadMessageImage === 'function',
+            toolApprovals: hasUsableApprovalSecret(options.approvalSecret),
+        });
+        this.now = options.now ?? Date.now;
+        this.approvalSecret = options.approvalSecret;
+        this.settleApproval = options.settleApproval;
+        this.recoverApprovalSettlement = options.recoverApprovalSettlement;
+        this.settleModelSelection = options.settleModelSelection;
+        this.settlePermissionSelection = options.settlePermissionSelection;
+        this.loadModelPicker = options.loadModelPicker;
+        this.advanceModelPicker = options.advanceModelPicker;
+        this.statusReactions = options.statusReactions ?? true;
+        this.progressPresenter = new LarkProgressPresenter(transport, options.showProgress ?? true, error => this.recordPresentationFailure(error));
+    }
+    async start(context) {
+        this.state = 'connecting';
+        const unsubscribe = this.transport.subscribe({
+            message: async (message) => {
+                const normalized = normalizeLarkMessage(this.config, message, this.now());
+                if (normalized.outcome !== 'accept')
+                    return;
+                const accepted = await context.accept(normalized.envelope);
+                if (this.statusReactions && !accepted.duplicate && accepted.status === 'queued') {
+                    // The durable Inbox acknowledgement is the critical path. A slow or
+                    // unavailable reaction endpoint must not hold the WebSocket handler open.
+                    void this.addReaction(message.messageId, 'Get');
+                }
+            },
+            cardAction: async (action) => this.handleCardAction(action),
+            reconnecting: () => {
+                this.cancelPendingToolApprovals('unavailable');
+                this.gapGeneration += 1;
+                this.state = 'reconnecting';
+            },
+            reconnected: () => { this.state = 'connected-with-gap'; },
+            error: error => {
+                this.lastErrorCode = error.code;
+                if (error.code === 'not_connected') {
+                    this.state = 'disconnected';
+                    this.cancelPendingToolApprovals('unavailable');
+                }
+            },
+        });
+        try {
+            await this.transport.connect();
+            this.state = 'connected';
+        }
+        catch (error) {
+            unsubscribe();
+            this.state = 'disconnected';
+            this.cancelPendingToolApprovals('unavailable', true);
+            await this.transport.disconnect().catch(() => { });
+            throw error;
+        }
+        let active = true;
+        return async () => {
+            if (!active)
+                return;
+            active = false;
+            unsubscribe();
+            this.state = 'disconnected';
+            this.cancelPendingToolApprovals('unavailable', true);
+            await this.transport.disconnect();
+        };
+    }
+    health() {
+        return {
+            state: this.state,
+            gapGeneration: this.gapGeneration,
+            ...(this.lastErrorCode === undefined ? {} : { lastErrorCode: this.lastErrorCode }),
+        };
+    }
+    async progress(intent) {
+        if (!this.matchesTarget(intent.target))
+            return;
+        await this.progressPresenter.publish(intent);
+    }
+    async requestToolApproval(input, signal) {
+        if (signal.aborted)
+            return 'cancelled';
+        if (!hasUsableApprovalSecret(this.approvalSecret)
+            || (this.state !== 'connected' && this.state !== 'connected-with-gap')
+            || !this.matchesTarget(input.target)
+            || !larkCallbackIdentifier.test(input.target.conversation.chat)
+            || !larkCallbackIdentifier.test(input.target.principal.user)
+            || input.target.conversation.kind !== 'dm'
+            || input.target.conversation.thread !== undefined
+            || typeof input.callId !== 'string'
+            || typeof input.arguments !== 'string'
+            || !boundedReviewText(input.reason, LARK_TOOL_APPROVAL_REASON_MAX_BYTES)
+            || !boundedReviewText(input.arguments, LARK_TOOL_APPROVAL_ARGUMENTS_MAX_BYTES)) {
+            return 'unavailable';
+        }
+        let now;
+        try {
+            now = this.now();
+        }
+        catch {
+            return 'unavailable';
+        }
+        if (!Number.isSafeInteger(now) || now < 0 || !Number.isSafeInteger(input.expiresAt)
+            || !Number.isSafeInteger(input.expiresAt - now) || now >= input.expiresAt) {
+            return 'unavailable';
+        }
+        const previousTombstone = this.toolApprovalTombstones.get(input.operationId);
+        if (previousTombstone !== undefined) {
+            if (now < previousTombstone.expiresAt)
+                return 'unavailable';
+            const expiredPending = this.pendingToolApprovals.get(input.operationId);
+            if (expiredPending !== undefined)
+                this.settleToolApproval(expiredPending, 'unavailable');
+            this.deleteToolApprovalTombstone(input.operationId, previousTombstone);
+        }
+        const payload = {
+            version: 1,
+            channel: this.channel,
+            account: this.account,
+            tenant: this.config.tenant,
+            operationId: input.operationId,
+            bindingId: input.bindingId,
+            chatId: input.target.conversation.chat,
+            ownerUser: input.target.principal.user,
+            actionHash: input.actionHash,
+            toolName: input.toolName,
+            callId: input.callId,
+            expiresAt: input.expiresAt,
+        };
+        let card;
+        try {
+            card = { toolApproval: {
+                    title: '工具调用需要确认',
+                    toolName: input.toolName,
+                    ...(input.reason === undefined ? {} : { reason: input.reason }),
+                    arguments: input.arguments,
+                    allowValue: { toolApproval: signLarkToolApprovalAction(this.approvalSecret, { ...payload, decision: 'allowed-once' }) },
+                    rejectValue: { toolApproval: signLarkToolApprovalAction(this.approvalSecret, { ...payload, decision: 'rejected' }) },
+                } };
+            if (Buffer.byteLength(renderLarkMessage(card).content, 'utf8') > LARK_APPROVAL_CARD_MAX_BYTES) {
+                return 'unavailable';
+            }
+        }
+        catch {
+            return 'unavailable';
+        }
+        let resolve;
+        const outcome = new Promise(settle => { resolve = settle; });
+        let pending;
+        const abort = () => { this.settleToolApproval(pending, 'cancelled'); };
+        pending = { payload, signal, abort, resolve };
+        const tombstone = { expiresAt: input.expiresAt };
+        this.pendingToolApprovals.set(input.operationId, pending);
+        this.toolApprovalTombstones.set(input.operationId, tombstone);
+        signal.addEventListener('abort', abort, { once: true });
+        if (signal.aborted) {
+            this.settleToolApproval(pending, 'cancelled');
+            return outcome;
+        }
+        this.armToolApprovalTombstone(input.operationId, tombstone);
+        if (this.pendingToolApprovals.get(input.operationId) !== pending)
+            return outcome;
+        const sendOptions = {
+            requestKey: `tool-approval:${input.operationId}:${input.actionHash}`,
+        };
+        let sending;
+        try {
+            sending = Promise.resolve(this.transport.send(input.target.conversation.chat, card, sendOptions));
+        }
+        catch (error) {
+            this.recordPresentationFailure(error);
+            this.settleToolApproval(pending, 'unavailable');
+            return outcome;
+        }
+        void sending.then(result => {
+            if (this.pendingToolApprovals.get(input.operationId) !== pending)
+                return;
+            if (!larkProviderMessageIdentifier.test(result.messageId)) {
+                this.settleToolApproval(pending, 'unavailable');
+                return;
+            }
+            pending.providerMessageId = result.messageId;
+            const earlyAction = pending.earlyAction;
+            delete pending.earlyAction;
+            if (earlyAction?.messageId === result.messageId) {
+                this.settleToolApproval(pending, earlyAction.decision);
+            }
+        }, error => {
+            this.recordPresentationFailure(error);
+            this.settleToolApproval(pending, 'unavailable');
+        });
+        return outcome;
+    }
+    async readInboundImage(input, signal) {
+        if (input.attachment.resourceType !== 'image') {
+            return { outcome: 'not-downloaded', failureCode: 'lark-image-type-unsupported', retryable: false };
+        }
+        const identifier = /^[A-Za-z0-9][A-Za-z0-9._@-]{0,255}$/u;
+        if (!identifier.test(input.eventId) || !identifier.test(input.attachment.providerRef)
+            || !Number.isSafeInteger(input.maxBytes) || input.maxBytes < 1) {
+            return { outcome: 'not-downloaded', failureCode: 'lark-image-reference-invalid', retryable: false };
+        }
+        if (signal.aborted) {
+            return { outcome: 'not-downloaded', failureCode: 'lark-image-aborted', retryable: true };
+        }
+        const download = this.transport.downloadMessageImage;
+        if (typeof download !== 'function') {
+            return { outcome: 'not-downloaded', failureCode: 'lark-image-download-unavailable', retryable: false };
+        }
+        try {
+            const image = await download.call(this.transport, input.eventId, input.attachment.providerRef, { maxBytes: input.maxBytes, signal });
+            if (signal.aborted) {
+                return { outcome: 'not-downloaded', failureCode: 'lark-image-aborted', retryable: true };
+            }
+            return {
+                outcome: 'downloaded',
+                data: image.data,
+                mediaType: image.mediaType,
+            };
+        }
+        catch (error) {
+            if (signal.aborted) {
+                return { outcome: 'not-downloaded', failureCode: 'lark-image-aborted', retryable: true };
+            }
+            const code = error instanceof LarkTransportError ? error.code : 'unknown';
+            const retryable = code !== 'format_error' && code !== 'permission_denied' && code !== 'target_revoked';
+            return {
+                outcome: 'not-downloaded',
+                failureCode: `lark-image-${code.replaceAll('_', '-')}`,
+                retryable,
+                ...(error instanceof LarkTransportError && error.retryAfterMs !== undefined
+                    ? { retryAfterMs: error.retryAfterMs }
+                    : {}),
+            };
+        }
+    }
+    async send(intent, signal) {
+        const conversation = intent.target.conversation;
+        if (!this.matchesTarget(intent.target)) {
+            return { outcome: 'not-sent', failureCode: 'lark-route-mismatch', retryable: false };
+        }
+        if (signal.aborted)
+            return { outcome: 'not-sent', failureCode: 'lark-aborted', retryable: true };
+        let input;
+        if (intent.format === 'approval') {
+            if (intent.approval === undefined || this.approvalSecret === undefined || this.settleApproval === undefined) {
+                return { outcome: 'not-sent', failureCode: 'lark-approval-unavailable', retryable: false };
+            }
+            if (Buffer.byteLength(intent.text, 'utf8') > this.config.maxTextBytes) {
+                return { outcome: 'not-sent', failureCode: 'lark-approval-too-large', retryable: false };
+            }
+            if (createHash('sha256').update(intent.text).digest('hex') !== intent.approval.diffHash) {
+                return { outcome: 'not-sent', failureCode: 'lark-approval-diff-mismatch', retryable: false };
+            }
+            if (this.now() >= intent.approval.expiresAt) {
+                return { outcome: 'not-sent', failureCode: 'lark-approval-expired', retryable: false };
+            }
+            const common = {
+                version: 2,
+                channel: conversation.channel,
+                account: conversation.account,
+                tenant: conversation.tenant,
+                operationId: intent.approval.operationId,
+                bindingId: intent.bindingId,
+                proposalId: intent.approval.proposalId,
+                expectedVersion: intent.approval.expectedVersion,
+                expiresAt: intent.approval.expiresAt,
+                chatId: conversation.chat,
+                diffHash: intent.approval.diffHash,
+            };
+            input = { approval: {
+                    title: intent.approval.title,
+                    body: intent.text,
+                    approveValue: { approval: signLarkApprovalAction(this.approvalSecret, { ...common, decision: 'approved' }) },
+                    rejectValue: { approval: signLarkApprovalAction(this.approvalSecret, { ...common, decision: 'rejected' }) },
+                } };
+            if (Buffer.byteLength(renderLarkMessage(input).content, 'utf8') > LARK_APPROVAL_CARD_MAX_BYTES) {
+                return { outcome: 'not-sent', failureCode: 'lark-approval-too-large', retryable: false };
+            }
+        }
+        else if (intent.format === 'permission-picker') {
+            if (intent.permissionPicker === undefined || this.approvalSecret === undefined
+                || this.settlePermissionSelection === undefined) {
+                return { outcome: 'not-sent', failureCode: 'lark-permission-picker-unavailable', retryable: false };
+            }
+            if (this.now() >= intent.permissionPicker.expiresAt) {
+                return { outcome: 'not-sent', failureCode: 'lark-permission-picker-expired', retryable: false };
+            }
+            input = { permissionPicker: permissionPickerCard(intent.permissionPicker, this.approvalSecret, {
+                    channel: conversation.channel,
+                    account: conversation.account,
+                    tenant: conversation.tenant,
+                    bindingId: intent.bindingId,
+                    chatId: conversation.chat,
+                    ownerUser: intent.target.principal.user,
+                }) };
+        }
+        else if (intent.format === 'model-picker') {
+            if (intent.modelPicker === undefined || this.approvalSecret === undefined
+                || this.settleModelSelection === undefined || this.loadModelPicker === undefined
+                || this.advanceModelPicker === undefined) {
+                return { outcome: 'not-sent', failureCode: 'lark-model-picker-unavailable', retryable: false };
+            }
+            if (this.now() >= intent.modelPicker.expiresAt) {
+                return { outcome: 'not-sent', failureCode: 'lark-model-picker-expired', retryable: false };
+            }
+            const picker = intent.modelPicker;
+            input = { modelPicker: modelPickerCard(picker, this.approvalSecret, {
+                    operationId: picker.operationId,
+                    bindingId: intent.bindingId,
+                    expiresAt: picker.expiresAt,
+                    chatId: conversation.chat,
+                    revision: 0,
+                }) };
+        }
+        else {
+            input = intent.format === 'markdown' ? { markdown: intent.text } : { text: intent.text };
+        }
+        // A synthetic lane represents all standalone group messages from one
+        // sender. Replying to the inbound event would make Lark create a provider
+        // thread; the user's next reply would then carry a real rootId and be
+        // normalized into a different Delivery conversation/session. Keep this
+        // lane top-level so later standalone messages retain the same context.
+        const syntheticTopLevelGroup = conversation.kind === 'group'
+            && isLarkTopLevelSenderThread(conversation.thread);
+        const providerReplyTarget = syntheticTopLevelGroup
+            ? undefined
+            : (intent.replyToEventId
+                ?? (conversation.kind === 'group' ? conversation.thread : undefined));
+        const options = {
+            requestKey: intent.idempotencyKey,
+            ...(providerReplyTarget === undefined ? {} : { replyTo: providerReplyTarget }),
+            ...(conversation.kind === 'group' && providerReplyTarget !== undefined ? { replyInThread: true } : {}),
+        };
+        let result;
+        try {
+            result = await this.transport.send(conversation.chat, input, options);
+        }
+        catch (error) {
+            if (!(error instanceof LarkTransportError) || error.code !== 'format_error') {
+                return sendFailure(error);
+            }
+            const fallback = intent.format === 'permission-picker' && intent.permissionPicker !== undefined
+                ? { text: intent.text, suffix: 'permission-picker-fallback' }
+                : intent.format === 'model-picker' && intent.modelPicker !== undefined
+                    ? { text: modelPickerFallbackText(intent), suffix: 'model-picker-fallback' }
+                    : undefined;
+            if (fallback === undefined)
+                return sendFailure(error);
+            try {
+                result = await this.transport.send(conversation.chat, { text: fallback.text }, {
+                    ...options,
+                    requestKey: `${intent.idempotencyKey}:${fallback.suffix}`,
+                });
+            }
+            catch (fallbackError) {
+                return sendFailure(fallbackError);
+            }
+        }
+        if (!/^[A-Za-z0-9][A-Za-z0-9._@/-]{0,255}$/u.test(result.messageId)) {
+            return { outcome: 'unknown', failureCode: 'invalid-provider-result' };
+        }
+        if (this.statusReactions && intent.replyToEventId !== undefined) {
+            void this.addReaction(intent.replyToEventId, 'DONE');
+        }
+        return { outcome: 'accepted', providerMessageId: result.messageId };
+    }
+    matchesTarget(target) {
+        const { conversation, principal } = target;
+        return conversation.channel === this.channel
+            && principal.channel === this.channel
+            && conversation.account === this.account
+            && principal.account === this.account
+            && conversation.tenant === this.config.tenant
+            && principal.tenant === this.config.tenant;
+    }
+    armToolApprovalTombstone(operationId, tombstone) {
+        const expire = () => {
+            if (this.toolApprovalTombstones.get(operationId) !== tombstone)
+                return;
+            let remaining;
+            try {
+                remaining = tombstone.expiresAt - this.now();
+            }
+            catch {
+                const pending = this.pendingToolApprovals.get(operationId);
+                if (pending !== undefined)
+                    this.settleToolApproval(pending, 'unavailable');
+                tombstone.timer = setTimeout(expire, 1_000);
+                tombstone.timer.unref();
+                return;
+            }
+            if (!Number.isSafeInteger(remaining)) {
+                const pending = this.pendingToolApprovals.get(operationId);
+                if (pending !== undefined)
+                    this.settleToolApproval(pending, 'unavailable');
+                tombstone.timer = setTimeout(expire, 1_000);
+                tombstone.timer.unref();
+                return;
+            }
+            if (remaining <= 0) {
+                const pending = this.pendingToolApprovals.get(operationId);
+                if (pending !== undefined)
+                    this.settleToolApproval(pending, 'unavailable');
+                this.deleteToolApprovalTombstone(operationId, tombstone);
+                return;
+            }
+            tombstone.timer = setTimeout(expire, Math.min(remaining, LARK_TOOL_APPROVAL_MAX_TIMER_MS));
+            tombstone.timer.unref();
+        };
+        expire();
+    }
+    deleteToolApprovalTombstone(operationId, tombstone) {
+        if (this.toolApprovalTombstones.get(operationId) !== tombstone)
+            return false;
+        this.toolApprovalTombstones.delete(operationId);
+        if (tombstone.timer !== undefined)
+            clearTimeout(tombstone.timer);
+        return true;
+    }
+    settleToolApproval(pending, outcome) {
+        if (this.pendingToolApprovals.get(pending.payload.operationId) !== pending)
+            return false;
+        this.pendingToolApprovals.delete(pending.payload.operationId);
+        pending.signal.removeEventListener('abort', pending.abort);
+        pending.resolve(outcome);
+        return true;
+    }
+    cancelPendingToolApprovals(outcome, clearTombstones = false) {
+        for (const pending of this.pendingToolApprovals.values()) {
+            this.settleToolApproval(pending, outcome);
+        }
+        if (!clearTombstones)
+            return;
+        for (const [operationId, tombstone] of this.toolApprovalTombstones) {
+            this.deleteToolApprovalTombstone(operationId, tombstone);
+        }
+    }
+    async addReaction(messageId, emojiType) {
+        try {
+            await this.transport.addReaction(messageId, emojiType);
+        }
+        catch (error) {
+            this.recordPresentationFailure(error);
+        }
+    }
+    recordPresentationFailure(error) {
+        this.lastErrorCode = error instanceof LarkTransportError ? error.code : 'unknown';
+    }
+    async handleCardAction(action) {
+        try {
+            const value = action.value;
+            if (value === null || typeof value !== 'object' || Array.isArray(value)) {
+                throw new LarkApprovalError('invalid', 'Lark card action value is invalid');
+            }
+            if (typeof value.toolApproval === 'string') {
+                if (Object.keys(value).length !== 1) {
+                    throw new LarkToolApprovalError('invalid', 'Lark tool approval action value is invalid');
+                }
+                return this.handleToolApprovalAction(action, value.toolApproval);
+            }
+            if (Object.prototype.hasOwnProperty.call(value, 'permissionPicker')) {
+                return await this.handlePermissionPickerAction(action, parseLarkPermissionPickerCallback(value));
+            }
+            if (typeof value.modelPicker === 'string') {
+                return await this.handleModelPickerAction(action, parseLarkModelPickerCallback(value));
+            }
+            if (Object.keys(value).length !== 1 || typeof value.approval !== 'string'
+                || this.approvalSecret === undefined) {
+                throw new LarkApprovalError('invalid', 'Lark approval action value is invalid');
+            }
+            const token = value.approval;
+            let expired = false;
+            let payload;
+            try {
+                payload = verifyLarkApprovalAction(this.approvalSecret, token, this.now());
+            }
+            catch (error) {
+                if (!(error instanceof LarkApprovalError) || error.code !== 'expired')
+                    throw error;
+                payload = verifyLarkApprovalActionForRecovery(this.approvalSecret, token);
+                expired = true;
+            }
+            if (payload.channel !== this.channel || payload.account !== this.account
+                || payload.tenant !== this.config.tenant || payload.chatId !== action.chatId) {
+                throw new LarkApprovalError('invalid', 'Lark approval route does not match');
+            }
+            const callbackEventId = createHash('sha256')
+                .update(`${action.messageId}\0${action.operatorId}\0${token}`)
+                .digest('hex');
+            const settlement = {
+                operationId: payload.operationId,
+                callbackEventId,
+                callbackChatId: action.chatId,
+                bindingId: payload.bindingId,
+                principal: { channel: 'lark', account: this.account, tenant: this.config.tenant, user: action.operatorId },
+                proposalId: payload.proposalId,
+                expectedVersion: payload.expectedVersion,
+                diffHash: payload.diffHash,
+                decision: payload.decision,
+                reason: `Lark owner ${payload.decision}`,
+            };
+            if (expired) {
+                if (this.recoverApprovalSettlement === undefined
+                    || await this.recoverApprovalSettlement(settlement) === undefined) {
+                    throw new LarkApprovalError('invalid', 'expired Lark approval settlement is not recoverable');
+                }
+            }
+            else {
+                if (this.settleApproval === undefined) {
+                    throw new LarkApprovalError('invalid', 'Lark approval settlement is unavailable');
+                }
+                await this.settleApproval(settlement);
+            }
+        }
+        catch (error) {
+            if (error instanceof LarkPermissionPickerError) {
+                this.lastErrorCode = 'format_error';
+                return { toast: { type: 'warning', content: error.code === 'expired'
+                            ? '权限卡片已过期，请重新发送 /permission'
+                            : '权限卡片无效或已失效，请重新发送 /permission' } };
+            }
+            if (error instanceof LarkApprovalError || error instanceof LarkModelPickerError
+                || error instanceof LarkToolApprovalError) {
+                this.lastErrorCode = 'format_error';
+                return;
+            }
+            throw error;
+        }
+    }
+    async handlePermissionPickerAction(action, callback) {
+        if (!hasUsableApprovalSecret(this.approvalSecret) || this.settlePermissionSelection === undefined
+            || action.tag !== 'button' || !larkProviderMessageIdentifier.test(action.messageId)) {
+            throw new LarkPermissionPickerError('invalid', 'Lark permission picker callback is unavailable');
+        }
+        const token = callback.permissionPicker;
+        const payload = verifyLarkPermissionPickerAction(this.approvalSecret, token, this.now());
+        if (payload.channel !== this.channel || payload.account !== this.account
+            || payload.tenant !== this.config.tenant || payload.chatId !== action.chatId
+            || payload.ownerUser !== action.operatorId) {
+            throw new LarkPermissionPickerError('invalid', 'Lark permission picker route does not match');
+        }
+        const callbackEventId = createHash('sha256')
+            .update(`${action.messageId}\0${action.operatorId}\0${token}`)
+            .digest('hex');
+        try {
+            await this.settlePermissionSelection({
+                operationId: payload.operationId,
+                callbackEventId,
+                callbackChatId: action.chatId,
+                cardMessageId: action.messageId,
+                bindingId: payload.bindingId,
+                bindingVersion: payload.bindingVersion,
+                sessionId: payload.sessionId,
+                principal: {
+                    channel: payload.channel,
+                    account: payload.account,
+                    tenant: payload.tenant,
+                    user: payload.ownerUser,
+                },
+                issuedAt: payload.issuedAt,
+                expiresAt: payload.expiresAt,
+                expectedStateHash: payload.expectedStateHash,
+                emergencyStopVersion: payload.emergencyStopVersion,
+                targetLevel: payload.level,
+            });
+            return { toast: { type: 'success', content: '权限切换已受理' } };
+        }
+        catch (error) {
+            this.recordPresentationFailure(error);
+            return { toast: { type: 'warning', content: '权限卡片状态已更新，请重新发送 /permission' } };
+        }
+    }
+    handleToolApprovalAction(action, token) {
+        if (!hasUsableApprovalSecret(this.approvalSecret) || action.tag !== 'button'
+            || !larkProviderMessageIdentifier.test(action.messageId)) {
+            throw new LarkToolApprovalError('invalid', 'Lark tool approval callback is unavailable');
+        }
+        const payload = verifyLarkToolApprovalAction(this.approvalSecret, token, this.now());
+        if (payload.channel !== this.channel || payload.account !== this.account
+            || payload.tenant !== this.config.tenant || payload.chatId !== action.chatId
+            || payload.ownerUser !== action.operatorId) {
+            throw new LarkToolApprovalError('invalid', 'Lark tool approval route does not match');
+        }
+        const pending = this.pendingToolApprovals.get(payload.operationId);
+        if (pending === undefined || !sameToolApprovalPayload(pending.payload, payload)) {
+            throw new LarkToolApprovalError('invalid', 'Lark tool approval request does not match');
+        }
+        if (pending.providerMessageId === undefined) {
+            const earlyAction = pending.earlyAction;
+            if (earlyAction !== undefined && (earlyAction.messageId !== action.messageId
+                || earlyAction.decision !== payload.decision)) {
+                throw new LarkToolApprovalError('invalid', 'Lark tool approval request does not match');
+            }
+            pending.earlyAction = { messageId: action.messageId, decision: payload.decision };
+            return { toast: { type: 'info', content: '正在确认工具审批卡片' } };
+        }
+        if (pending.providerMessageId !== action.messageId) {
+            throw new LarkToolApprovalError('invalid', 'Lark tool approval request does not match');
+        }
+        if (!this.settleToolApproval(pending, payload.decision)) {
+            throw new LarkToolApprovalError('invalid', 'Lark tool approval request is no longer pending');
+        }
+        return { toast: { type: payload.decision === 'allowed-once' ? 'success' : 'info',
+                content: payload.decision === 'allowed-once' ? '已仅允许本次工具调用' : '已拒绝工具调用' } };
+    }
+    async handleModelPickerAction(action, callback) {
+        if (this.approvalSecret === undefined || this.settleModelSelection === undefined) {
+            throw new LarkModelPickerError('invalid', 'Lark model picker callback is unavailable');
+        }
+        const token = callback.modelPicker;
+        const payload = verifyLarkModelPickerAction(this.approvalSecret, token, this.now());
+        if (payload.chatId !== action.chatId)
+            throw new LarkModelPickerError('invalid', 'Lark model picker chat does not match');
+        if (payload.action !== 'confirm') {
+            const selectedOption = action.option;
+            if (this.loadModelPicker === undefined || this.advanceModelPicker === undefined
+                || typeof selectedOption !== 'string') {
+                throw new LarkModelPickerError('invalid', 'Lark model picker navigation is unavailable');
+            }
+            if (action.tag !== 'select_static') {
+                throw new LarkModelPickerError('invalid', 'Lark model picker navigation action is invalid');
+            }
+            let picker;
+            try {
+                picker = await this.loadModelPicker({
+                    operationId: payload.operationId,
+                    callbackChatId: action.chatId,
+                    bindingId: payload.bindingId,
+                    principal: { channel: 'lark', account: this.account, tenant: this.config.tenant, user: action.operatorId },
+                });
+            }
+            catch (error) {
+                this.recordPresentationFailure(error);
+                return { toast: { type: 'warning', content: '模型选择已结束，请重新发送 /model' } };
+            }
+            if (picker === undefined || picker.operationId !== payload.operationId || picker.expiresAt !== payload.expiresAt) {
+                return { toast: { type: 'warning', content: '模型选择已结束，请重新发送 /model' } };
+            }
+            const capability = {
+                operationId: payload.operationId,
+                bindingId: payload.bindingId,
+                expiresAt: payload.expiresAt,
+                chatId: payload.chatId,
+            };
+            let preferred;
+            if (payload.action === 'provider') {
+                if (!picker.providers.some(provider => provider.id === selectedOption)
+                    || !picker.models.some(model => model.provider === selectedOption)) {
+                    throw new LarkModelPickerError('invalid', 'Lark model picker provider is unavailable');
+                }
+                preferred = {
+                    provider: selectedOption,
+                    effort: null,
+                };
+            }
+            else if (payload.action === 'model') {
+                const selected = routeParts(selectedOption);
+                if (selected === undefined || selected.provider !== payload.provider
+                    || !picker.models.some(model => model.provider === selected.provider && model.id === selected.model)) {
+                    throw new LarkModelPickerError('invalid', 'Lark model picker model is unavailable');
+                }
+                preferred = {
+                    provider: selected.provider,
+                    route: selectedOption,
+                    effort: null,
+                };
+            }
+            else {
+                const selectedModel = picker.models.find(model => model.provider === payload.provider && model.id === payload.model);
+                const defaultEffort = selectedModel === undefined ? undefined : defaultEffortOption(selectedModel.effortIds);
+                if (selectedModel === undefined || (selectedOption !== defaultEffort && !selectedModel.effortIds.includes(selectedOption))) {
+                    throw new LarkModelPickerError('invalid', 'Lark model picker effort is unavailable');
+                }
+                preferred = {
+                    provider: payload.provider,
+                    route: `${payload.provider}/${payload.model}`,
+                    effort: selectedOption === defaultEffort ? null : selectedOption,
+                };
+            }
+            const next = resolvedModelRoute(resolveModelPicker(picker, preferred));
+            let advanced;
+            try {
+                advanced = await this.advanceModelPicker({
+                    operationId: payload.operationId,
+                    callbackChatId: action.chatId,
+                    bindingId: payload.bindingId,
+                    principal: { channel: 'lark', account: this.account, tenant: this.config.tenant, user: action.operatorId },
+                    expected: { revision: payload.revision, provider: payload.provider, model: payload.model,
+                        ...(payload.effort === null ? {} : { reasoningEffort: payload.effort }) },
+                    next,
+                });
+            }
+            catch (error) {
+                this.recordPresentationFailure(error);
+                return { toast: { type: 'warning', content: '模型选择已结束，请重新发送 /model' } };
+            }
+            const state = advanced.state;
+            return callbackCard(modelPickerCard(picker, this.approvalSecret, {
+                ...capability, revision: state.revision,
+            }, {
+                provider: state.provider,
+                route: `${state.provider}/${state.model}`,
+                effort: state.reasoningEffort ?? null,
+            }));
+        }
+        if (action.tag !== 'button') {
+            throw new LarkModelPickerError('invalid', 'Lark model picker confirmation action is invalid');
+        }
+        const callbackEventId = createHash('sha256')
+            .update(`${action.messageId}\0${action.operatorId}\0${token}`)
+            .digest('hex');
+        try {
+            await this.settleModelSelection({
+                operationId: payload.operationId,
+                callbackEventId,
+                callbackChatId: action.chatId,
+                bindingId: payload.bindingId,
+                principal: { channel: 'lark', account: this.account, tenant: this.config.tenant, user: action.operatorId },
+                provider: payload.provider,
+                modelProvider: payload.provider,
+                model: payload.model,
+                expectedRevision: payload.revision,
+                ...(payload.effort === null ? {} : { reasoningEffort: payload.effort }),
+            });
+            return { toast: { type: 'success', content: '模型切换已受理' } };
+        }
+        catch (error) {
+            this.recordPresentationFailure(error);
+            return { toast: { type: 'warning', content: '卡片状态已更新，请重新发送 /model' } };
+        }
+    }
+}
+//# sourceMappingURL=adapter.js.map