@dsh-enhanced/lark-channel 0.1.3

package/lib/sdk.js

@@ -0,0 +1,945 @@
+import { createHash } from 'node:crypto';
+import { Readable } from 'node:stream';
+import { AppType, Client, defaultHttpInstance, Domain, EventDispatcher, LoggerLevel, WSClient, normalize, normalizeCardAction, } from '@larksuiteoapi/node-sdk';
+import { LarkTransportError, } from './types.js';
+import { installLarkCardCallbackBridge } from './ws-card-callback.js';
+const LARK_PROGRESS_API = '/open-apis/im/v1/message_cot';
+const LARK_MESSAGE_RESOURCE_API = '/open-apis/im/v1/messages';
+const LARK_ERROR_BODY_MAX_BYTES = 16 * 1_024;
+const larkResourceIdentifier = /^[A-Za-z0-9][A-Za-z0-9._@-]{0,255}$/u;
+class LarkImageResponseValidationError extends Error {
+}
+function imageResponseValidationError(message) {
+    return new LarkImageResponseValidationError(message);
+}
+function assertResourceIdentifier(value, field) {
+    if (!larkResourceIdentifier.test(value)) {
+        throw new Error(`lark-channel: invalid ${field} identifier`);
+    }
+    return value;
+}
+export function createLarkImageResourceRequest(messageId, fileKey, options) {
+    const message = assertResourceIdentifier(messageId, 'message');
+    const resource = assertResourceIdentifier(fileKey, 'image resource');
+    if (!Number.isSafeInteger(options.timeoutMs) || options.timeoutMs < 1
+        || !Number.isSafeInteger(options.maxBytes) || options.maxBytes < 1) {
+        throw new Error('lark-channel: invalid image resource request limits');
+    }
+    return {
+        method: 'GET',
+        url: `${LARK_MESSAGE_RESOURCE_API}/${encodeURIComponent(message)}/resources/${encodeURIComponent(resource)}`,
+        params: { type: 'image' },
+        responseType: 'stream',
+        timeout: options.timeoutMs,
+        signal: options.signal,
+        maxRedirects: 0,
+        maxContentLength: options.maxBytes,
+        maxBodyLength: options.maxBytes,
+        $return_headers: true,
+    };
+}
+function responseHeader(headers, name) {
+    if ('get' in headers && typeof headers.get === 'function')
+        return headers.get(name);
+    const record = headers;
+    const expected = name.toLowerCase();
+    for (const [header, value] of Object.entries(record)) {
+        if (header.toLowerCase() === expected)
+            return value;
+    }
+    return undefined;
+}
+function declaredContentLength(headers) {
+    const value = responseHeader(headers, 'content-length');
+    if (value === undefined)
+        return undefined;
+    const text = Array.isArray(value) ? value[0] : value;
+    if ((typeof text !== 'string' && typeof text !== 'number') || !/^\d+$/u.test(String(text))) {
+        throw imageResponseValidationError('lark-channel: invalid image resource content length');
+    }
+    const length = Number(text);
+    if (!Number.isSafeInteger(length)) {
+        throw imageResponseValidationError('lark-channel: invalid image resource content length');
+    }
+    return length;
+}
+function imageMediaType(data) {
+    if (data.length >= 8
+        && data[0] === 0x89 && data[1] === 0x50 && data[2] === 0x4e && data[3] === 0x47
+        && data[4] === 0x0d && data[5] === 0x0a && data[6] === 0x1a && data[7] === 0x0a)
+        return 'image/png';
+    if (data.length >= 3 && data[0] === 0xff && data[1] === 0xd8 && data[2] === 0xff)
+        return 'image/jpeg';
+    if (data.length >= 6) {
+        const signature = Buffer.from(data.subarray(0, 6)).toString('ascii');
+        if (signature === 'GIF87a' || signature === 'GIF89a')
+            return 'image/gif';
+    }
+    if (data.length >= 12
+        && Buffer.from(data.subarray(0, 4)).toString('ascii') === 'RIFF'
+        && Buffer.from(data.subarray(8, 12)).toString('ascii') === 'WEBP')
+        return 'image/webp';
+    return undefined;
+}
+function declaredImageMediaType(headers) {
+    const value = responseHeader(headers, 'content-type');
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== 'string') {
+        throw imageResponseValidationError('lark-channel: invalid image resource content type');
+    }
+    const mediaType = value.split(';', 1)[0].trim().toLowerCase();
+    if (mediaType === 'application/octet-stream')
+        return undefined;
+    if (mediaType === 'image/gif' || mediaType === 'image/jpeg'
+        || mediaType === 'image/png' || mediaType === 'image/webp')
+        return mediaType;
+    throw imageResponseValidationError('lark-channel: unsupported image resource content type');
+}
+function abortReason(signal) {
+    return signal.reason instanceof Error ? signal.reason : new Error('lark-channel: image resource request aborted');
+}
+function boundedHttpOptions(options, hardTimeoutMs, lifecycleSignal) {
+    const source = options;
+    const requestedTimeout = source?.timeout;
+    const timeout = typeof requestedTimeout === 'number' && Number.isFinite(requestedTimeout) && requestedTimeout > 0
+        ? Math.min(requestedTimeout, hardTimeoutMs)
+        : hardTimeoutMs;
+    const hardTimeoutSignal = AbortSignal.timeout(hardTimeoutMs);
+    const signal = source?.signal === undefined
+        ? AbortSignal.any([hardTimeoutSignal, lifecycleSignal])
+        : AbortSignal.any([source.signal, hardTimeoutSignal, lifecycleSignal]);
+    return { ...source, timeout, signal };
+}
+function asSdkHttpResult(request) {
+    // The SDK's HttpInstance contract describes its response-interceptor output
+    // as R. Axios 1.19 leaves that conditional generic unresolved for arbitrary
+    // R even though defaultHttpInstance installs exactly that interceptor.
+    return request;
+}
+/**
+ * The SDK's token manager calls `httpInstance.post()` before the resource
+ * request exists, so request-local Axios limits cannot cover a cache miss.
+ * Keep the dedicated image client's entire HTTP stack bounded instead.
+ */
+function boundedImageHttpInstance(hardTimeoutMs, lifecycleSignal) {
+    if (!Number.isSafeInteger(hardTimeoutMs) || hardTimeoutMs < 1) {
+        throw new Error('lark-channel: invalid image HTTP timeout');
+    }
+    return {
+        request(options) {
+            return asSdkHttpResult(defaultHttpInstance.request(boundedHttpOptions(options, hardTimeoutMs, lifecycleSignal)));
+        },
+        get(url, options) {
+            return asSdkHttpResult(defaultHttpInstance.get(url, boundedHttpOptions(options, hardTimeoutMs, lifecycleSignal)));
+        },
+        delete(url, options) {
+            return asSdkHttpResult(defaultHttpInstance.delete(url, boundedHttpOptions(options, hardTimeoutMs, lifecycleSignal)));
+        },
+        head(url, options) {
+            return asSdkHttpResult(defaultHttpInstance.head(url, boundedHttpOptions(options, hardTimeoutMs, lifecycleSignal)));
+        },
+        options(url, options) {
+            return asSdkHttpResult(defaultHttpInstance.options(url, boundedHttpOptions(options, hardTimeoutMs, lifecycleSignal)));
+        },
+        post(url, data, options) {
+            return asSdkHttpResult(defaultHttpInstance.post(url, data, boundedHttpOptions(options, hardTimeoutMs, lifecycleSignal)));
+        },
+        put(url, data, options) {
+            return asSdkHttpResult(defaultHttpInstance.put(url, data, boundedHttpOptions(options, hardTimeoutMs, lifecycleSignal)));
+        },
+        patch(url, data, options) {
+            return asSdkHttpResult(defaultHttpInstance.patch(url, data, boundedHttpOptions(options, hardTimeoutMs, lifecycleSignal)));
+        },
+    };
+}
+function awaitImageResourceRequest(signal, request) {
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        const finish = (complete) => {
+            if (settled)
+                return false;
+            settled = true;
+            signal.removeEventListener('abort', abort);
+            complete();
+            return true;
+        };
+        const abort = () => { finish(() => reject(abortReason(signal))); };
+        signal.addEventListener('abort', abort, { once: true });
+        if (signal.aborted) {
+            abort();
+            return;
+        }
+        let pending;
+        try {
+            pending = request();
+        }
+        catch (error) {
+            finish(() => reject(error));
+            return;
+        }
+        void pending.then(response => {
+            if (!finish(() => resolve(response)) && response.data instanceof Readable)
+                response.data.destroy();
+        }, error => {
+            // The outer abort is authoritative. This rejection handler intentionally
+            // consumes a later Axios/token failure so credential-bearing request
+            // metadata can never surface as an unhandled rejection.
+            finish(() => reject(error));
+        });
+    });
+}
+export async function readLarkImageResourceResponse(response, options) {
+    if (!Number.isSafeInteger(options.maxBytes) || options.maxBytes < 1) {
+        response.data.destroy();
+        throw imageResponseValidationError('lark-channel: invalid image resource byte limit');
+    }
+    if (options.signal.aborted) {
+        response.data.destroy();
+        throw abortReason(options.signal);
+    }
+    let declaredLength;
+    let declaredType;
+    try {
+        declaredLength = declaredContentLength(response.headers);
+        declaredType = declaredImageMediaType(response.headers);
+    }
+    catch (error) {
+        response.data.destroy();
+        throw error;
+    }
+    if (declaredLength !== undefined && declaredLength > options.maxBytes) {
+        response.data.destroy();
+        throw imageResponseValidationError('lark-channel: image resource exceeds its byte limit');
+    }
+    const chunks = [];
+    let bytes = 0;
+    const abort = () => response.data.destroy(abortReason(options.signal));
+    options.signal.addEventListener('abort', abort, { once: true });
+    try {
+        for await (const value of response.data) {
+            if (options.signal.aborted)
+                throw abortReason(options.signal);
+            if (!(value instanceof Uint8Array)) {
+                throw imageResponseValidationError('lark-channel: invalid image resource stream chunk');
+            }
+            bytes += value.byteLength;
+            if (bytes > options.maxBytes) {
+                response.data.destroy();
+                throw imageResponseValidationError('lark-channel: image resource exceeds its byte limit');
+            }
+            chunks.push(Buffer.from(value.buffer, value.byteOffset, value.byteLength));
+        }
+    }
+    catch (error) {
+        if (options.signal.aborted)
+            throw abortReason(options.signal);
+        throw error;
+    }
+    finally {
+        options.signal.removeEventListener('abort', abort);
+    }
+    if (options.signal.aborted)
+        throw abortReason(options.signal);
+    if (declaredLength !== undefined && declaredLength !== bytes) {
+        throw new Error('lark-channel: image resource length does not match its response header');
+    }
+    const data = new Uint8Array(Buffer.concat(chunks, bytes));
+    const detectedType = imageMediaType(data);
+    if (detectedType === undefined) {
+        throw imageResponseValidationError('lark-channel: image resource has an unsupported byte signature');
+    }
+    if (declaredType !== undefined && declaredType !== detectedType) {
+        throw imageResponseValidationError('lark-channel: image resource content type does not match its bytes');
+    }
+    if (options.signal.aborted)
+        throw abortReason(options.signal);
+    return { data, mediaType: detectedType };
+}
+/** Provider-safe UTF-8 budget for the complete serialized approval card. */
+export const LARK_APPROVAL_CARD_MAX_BYTES = 28 * 1_024;
+function providerFailureCode(code) {
+    if (code === 99991400 || code === 230020)
+        return 'rate_limited';
+    if (code === 230027 || code === 234009 || code === 99991663
+        || code === 99991672 || code === 99991676 || code === 99991679)
+        return 'permission_denied';
+    if (code === 200530)
+        return 'format_error';
+    return undefined;
+}
+const silentLogger = {
+    error() { },
+    warn() { },
+    info() { },
+    debug() { },
+    trace() { },
+};
+const MAX_RETRY_AFTER_MS = 24 * 60 * 60 * 1_000;
+function retryAfter(headers) {
+    const value = headers === undefined ? undefined : responseHeader(headers, 'retry-after');
+    const delaySeconds = typeof value === 'number' && Number.isSafeInteger(value)
+        ? value
+        : typeof value === 'string' && /^\d+$/.test(value.trim())
+            ? Number(value.trim())
+            : Number.NaN;
+    const delayMs = delaySeconds * 1_000;
+    return Number.isSafeInteger(delayMs) && delayMs >= 0 && delayMs <= MAX_RETRY_AFTER_MS
+        ? delayMs
+        : undefined;
+}
+export function classifyLarkSdkFailure(error) {
+    const shape = error !== null && typeof error === 'object' ? error : {};
+    const status = typeof shape.response?.status === 'number' ? shape.response.status : undefined;
+    if (status === 429) {
+        const delay = retryAfter(shape.response?.headers);
+        return { code: 'rate_limited', ...(delay === undefined ? {} : { retryAfterMs: delay }) };
+    }
+    const responseData = shape.response?.data;
+    const responseCode = responseData !== null && typeof responseData === 'object' && !Array.isArray(responseData)
+        ? responseData.code
+        : undefined;
+    const providerCode = providerFailureCode(responseCode) ?? providerFailureCode(shape.code);
+    if (providerCode !== undefined) {
+        const delay = providerCode === 'rate_limited' ? retryAfter(shape.response?.headers) : undefined;
+        return { code: providerCode, ...(delay === undefined ? {} : { retryAfterMs: delay }) };
+    }
+    if (status === 401 || status === 403)
+        return { code: 'permission_denied' };
+    if (status !== undefined && status >= 400 && status < 500)
+        return { code: 'format_error' };
+    if (shape.code === 'ETIMEDOUT' || shape.code === 'ECONNABORTED')
+        return { code: 'send_timeout' };
+    return { code: 'unknown' };
+}
+async function streamedProviderFailureCode(stream, signal) {
+    if (signal.aborted) {
+        stream.destroy();
+        return undefined;
+    }
+    const chunks = [];
+    let bytes = 0;
+    let exceeded = false;
+    const abort = () => stream.destroy();
+    signal.addEventListener('abort', abort, { once: true });
+    try {
+        for await (const value of stream) {
+            if (!(value instanceof Uint8Array)) {
+                stream.destroy();
+                return undefined;
+            }
+            bytes += value.byteLength;
+            if (bytes > LARK_ERROR_BODY_MAX_BYTES) {
+                exceeded = true;
+                stream.destroy();
+                break;
+            }
+            chunks.push(Buffer.from(value.buffer, value.byteOffset, value.byteLength));
+        }
+    }
+    catch {
+        return undefined;
+    }
+    finally {
+        signal.removeEventListener('abort', abort);
+    }
+    if (exceeded || signal.aborted)
+        return undefined;
+    try {
+        const value = JSON.parse(Buffer.concat(chunks, bytes).toString('utf8'));
+        return value !== null && typeof value === 'object' && !Array.isArray(value)
+            ? value.code
+            : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export async function classifyLarkImageSdkFailure(error, signal) {
+    const shape = error !== null && typeof error === 'object' ? error : {};
+    const stream = shape.response?.data instanceof Readable ? shape.response.data : undefined;
+    if (stream === undefined)
+        return classifyLarkSdkFailure(error);
+    const status = typeof shape.response?.status === 'number' ? shape.response.status : undefined;
+    if (status !== 400) {
+        stream.destroy();
+        return classifyLarkSdkFailure(error);
+    }
+    const code = await streamedProviderFailureCode(stream, signal);
+    const classified = providerFailureCode(code);
+    if (classified === undefined)
+        return classifyLarkSdkFailure(error);
+    const delay = classified === 'rate_limited' ? retryAfter(shape.response?.headers) : undefined;
+    return { code: classified, ...(delay === undefined ? {} : { retryAfterMs: delay }) };
+}
+export function larkRequestUuid(idempotencyKey) {
+    return createHash('sha256').update(idempotencyKey).digest('hex').slice(0, 32);
+}
+export function createLarkProgressRequest(chatId, options) {
+    return {
+        method: 'POST',
+        url: `${LARK_PROGRESS_API}?receive_id_type=chat_id`,
+        data: {
+            receive_id: chatId,
+            origin_message_id: options.replyTo,
+            cot_hidden: options.hidden,
+            enable_badge: false,
+            update_feed_rank: false,
+        },
+    };
+}
+export function writeLarkProgressRequest(handle, events) {
+    return {
+        method: 'PUT',
+        url: LARK_PROGRESS_API,
+        data: {
+            cot_id: handle.cotId,
+            message_id: handle.messageId,
+            events: events.map(event => ({
+                event_type: event.eventType,
+                content: event.content,
+                timestamp: event.timestamp,
+            })),
+        },
+    };
+}
+export const LARK_MODEL_PICKER_CONTROLS = Object.freeze({
+    provider: 'model_provider',
+    model: 'model_route',
+    effort: 'model_effort',
+    confirm: 'model_confirm',
+});
+export const LARK_PERMISSION_PICKER_CONTROLS = Object.freeze({
+    ask: 'permission_ask',
+    auto: 'permission_auto',
+    full: 'permission_full',
+});
+export function renderLarkMessage(input) {
+    if ('text' in input)
+        return { msgType: 'text', content: JSON.stringify({ text: input.text }) };
+    if ('permissionPicker' in input) {
+        const picker = input.permissionPicker;
+        const level = (key, label, description) => {
+            const current = picker.current === key;
+            const value = picker.callbackValues[key];
+            const full = key === 'full';
+            return {
+                tag: 'interactive_container',
+                behaviors: [],
+                width: 'fill',
+                corner_radius: '8px',
+                has_border: true,
+                border_color: full ? 'orange-200' : current ? 'blue-200' : 'grey-200',
+                background_style: full ? 'orange-50' : current ? 'blue-50' : 'grey-50',
+                padding: '12px 12px 12px 12px',
+                direction: 'vertical',
+                vertical_spacing: '6px',
+                margin: '0px 0px 8px 0px',
+                elements: [
+                    { tag: 'div', text: { tag: 'plain_text', content: `${current ? '✓ ' : ''}${label}` } },
+                    { tag: 'div', text: { tag: 'plain_text', content: description } },
+                    {
+                        tag: 'button',
+                        name: LARK_PERMISSION_PICKER_CONTROLS[key],
+                        type: full ? 'danger' : current ? 'primary' : 'default',
+                        width: 'fill',
+                        text: { tag: 'plain_text', content: current ? '✓ 当前档位' : '选择此档位' },
+                        value,
+                        behaviors: [{ type: 'callback', value }],
+                        ...(full ? { confirm: {
+                                title: { tag: 'plain_text', content: '确认开启完全访问权限？' },
+                                text: { tag: 'plain_text', content: '开启后可访问互联网和电脑上的任何文件，并关闭逐次审批。' },
+                            } } : {}),
+                    },
+                ],
+            };
+        };
+        return {
+            msgType: 'interactive',
+            content: JSON.stringify({
+                schema: '2.0',
+                config: { enable_forward_interaction: false },
+                header: {
+                    template: 'blue',
+                    title: { tag: 'plain_text', content: picker.title },
+                    subtitle: { tag: 'plain_text', content: picker.body },
+                },
+                body: { padding: '12px 12px 12px 12px', elements: [
+                        level('ask', '请求批准（ask）', '编辑外部文件和使用互联网时始终询问'),
+                        level('auto', '帮我批准（auto）', '仅对检测到的风险操作请求批准'),
+                        level('full', '完全访问权限（full）', '不受限制地访问互联网和电脑上的任何文件，并关闭逐次审批'),
+                    ] },
+            }),
+        };
+    }
+    if ('modelPicker' in input) {
+        const picker = input.modelPicker;
+        const callback = (action) => picker.callbackValues[action];
+        const select = (name, placeholder, options, initial, action) => {
+            const value = callback(action);
+            // Lark resolves `initial_option` against the option's displayed text, not its
+            // callback value, so a route-shaped or synthetic initial value never matches and
+            // the client silently falls back to the first option. Address the selection by its
+            // 1-based `initial_index`, and only add the textual form when that label identifies
+            // exactly one option, because `initial_option` overrides `initial_index`. An initial
+            // value absent from `options` preselects nothing.
+            const selected = initial === undefined
+                ? -1
+                : options.findIndex(option => option.value === initial);
+            const label = selected < 0 ? undefined : options[selected].label;
+            const unambiguous = label !== undefined
+                && options.filter(option => option.label === label).length === 1;
+            return {
+                tag: 'select_static',
+                name,
+                width: 'fill',
+                placeholder: { tag: 'plain_text', content: placeholder },
+                options: options.map(option => ({
+                    text: { tag: 'plain_text', content: option.label },
+                    value: option.value,
+                })),
+                value,
+                behaviors: [{ type: 'callback', value }],
+                ...(selected < 0 ? {} : { initial_index: selected + 1 }),
+                ...(unambiguous ? { initial_option: label } : {}),
+            };
+        };
+        const confirmValue = callback('confirm');
+        // Layout follows the card style guide: header carries "what this is" (title + subtitle + icon),
+        // each of the three selects sits in its own bordered surface so the groups read as blocks
+        // instead of a flat run of markdown labels, and the single primary button is the only focus.
+        const field = (label, hint, control, last = false) => ({
+            tag: 'interactive_container',
+            behaviors: [],
+            width: 'fill',
+            corner_radius: '8px',
+            has_border: true,
+            border_color: 'blue-100',
+            background_style: 'blue-50',
+            padding: '12px 12px 12px 12px',
+            direction: 'vertical',
+            vertical_spacing: '4px',
+            // A trailing container keeps no bottom margin, so the card does not end on dead space.
+            margin: last ? '0px 0px 12px 0px' : '0px 0px 8px 0px',
+            elements: [
+                { tag: 'markdown', content: `**<font color='blue'>${label}</font>**`, text_align: 'left' },
+                { tag: 'markdown', content: `<font color='grey'>${hint}</font>`, text_size: 'notation', text_align: 'left' },
+                control,
+            ],
+        });
+        return {
+            msgType: 'interactive',
+            content: JSON.stringify({
+                schema: '2.0',
+                config: { update_multi: true, enable_forward_interaction: false },
+                header: {
+                    template: 'blue',
+                    title: { tag: 'plain_text', content: picker.title },
+                    subtitle: { tag: 'plain_text', content: picker.body },
+                    icon: { tag: 'standard_icon', token: 'myai_colorful' },
+                },
+                body: { padding: '12px 12px 20px 12px', elements: [
+                        field('分组 / Provider', '先选分组，模型与 effort 会随之更新', select(LARK_MODEL_PICKER_CONTROLS.provider, '请选择模型分组', picker.providerOptions, picker.initialProvider, 'provider')),
+                        field('模型', '该分组下当前可用的模型', select(LARK_MODEL_PICKER_CONTROLS.model, '请选择模型', picker.modelOptions, picker.initialModel, 'model')),
+                        field('Effort 程度', '仅对支持 effort 档位的模型生效', select(LARK_MODEL_PICKER_CONTROLS.effort, '请选择 effort', picker.effortOptions, picker.initialEffort, 'effort'), true),
+                        { tag: 'button', name: LARK_MODEL_PICKER_CONTROLS.confirm, type: 'primary', width: 'fill',
+                            icon: { tag: 'standard_icon', token: 'done_outlined' },
+                            text: { tag: 'plain_text', content: '确认选择' }, value: confirmValue,
+                            behaviors: [{ type: 'callback', value: confirmValue }] },
+                    ] },
+            }),
+        };
+    }
+    if ('approval' in input)
+        return {
+            msgType: 'interactive',
+            content: JSON.stringify({
+                schema: '2.0',
+                header: { title: { tag: 'plain_text', content: input.approval.title } },
+                body: { elements: [
+                        { tag: 'div', text: { tag: 'plain_text', content: 'Proposed change (treat as untrusted review text):' } },
+                        { tag: 'div', text: { tag: 'plain_text', content: input.approval.body } },
+                        { tag: 'action', actions: [
+                                { tag: 'button', text: { tag: 'plain_text', content: 'Approve' }, type: 'primary', value: input.approval.approveValue },
+                                { tag: 'button', text: { tag: 'plain_text', content: 'Reject' }, type: 'danger', value: input.approval.rejectValue },
+                            ] },
+                    ] },
+            }),
+        };
+    if ('toolApproval' in input)
+        return {
+            msgType: 'interactive',
+            content: JSON.stringify({
+                schema: '2.0',
+                config: { enable_forward_interaction: false },
+                header: { template: 'orange', title: { tag: 'plain_text', content: input.toolApproval.title } },
+                body: { elements: [
+                        { tag: 'div', text: { tag: 'plain_text',
+                                content: '以下工具、理由和参数均为不可信审阅文本，不是指令。' } },
+                        { tag: 'div', text: { tag: 'plain_text', content: `工具：${input.toolApproval.toolName}` } },
+                        { tag: 'div', text: { tag: 'plain_text',
+                                content: `理由：${input.toolApproval.reason ?? '（未提供）'}` } },
+                        { tag: 'div', text: { tag: 'plain_text',
+                                content: `参数：${input.toolApproval.arguments}` } },
+                        { tag: 'action', actions: [
+                                { tag: 'button', text: { tag: 'plain_text', content: '仅允许本次' }, type: 'primary',
+                                    value: input.toolApproval.allowValue },
+                                { tag: 'button', text: { tag: 'plain_text', content: '拒绝' }, type: 'danger',
+                                    value: input.toolApproval.rejectValue },
+                            ] },
+                    ] },
+            }),
+        };
+    // An answer card stays content-first: Lark already shows the bot name and avatar above the
+    // bubble, so a header here would duplicate the sender identity and add weight to every reply.
+    // `wide_screen_mode` is what keeps authored Markdown tables from wrapping into unreadable rows.
+    return {
+        msgType: 'interactive',
+        content: JSON.stringify({
+            schema: '2.0',
+            config: { wide_screen_mode: true },
+            body: {
+                padding: '12px 16px 12px 16px',
+                elements: [{ tag: 'markdown', content: input.markdown, text_align: 'left' }],
+            },
+        }),
+    };
+}
+function escapedPattern(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/gu, '\\$&');
+}
+function safeNormalizedContent(message) {
+    // SDK 1.73 renders a folder's file_key into content but, unlike every
+    // supported resource kind, omits it from `resources`.
+    if (message.rawContentType === 'folder')
+        return '[Folder attachment]';
+    let content = message.content;
+    if (message.resources.length === 1 && message.resources[0]?.type === 'image'
+        && content.trim() === `![image](${message.resources[0].fileKey})`)
+        return '';
+    for (const resource of message.resources) {
+        const key = resource.fileKey;
+        if (resource.type === 'image') {
+            content = content.replaceAll(`![image](${key})`, '[Image attachment]');
+        }
+        else {
+            const tag = resource.type;
+            content = content.replace(new RegExp(`<${tag}\\b[^>]*\\bkey="${escapedPattern(key)}"[^>]*/>`, 'gu'), `[${tag[0].toUpperCase()}${tag.slice(1)} attachment]`);
+        }
+        // Defense in depth for future SDK renderings: a provider capability key
+        // is never user-facing text and must not cross into the model prompt.
+        content = content.replaceAll(key, '[redacted-resource]');
+    }
+    return content.trim();
+}
+export function toSafeLarkMessage(message) {
+    return {
+        messageId: message.messageId,
+        chatId: message.chatId,
+        chatType: message.chatType,
+        senderId: message.senderId,
+        content: safeNormalizedContent(message),
+        rawContentType: message.rawContentType,
+        resources: message.resources,
+        mentionAll: message.mentionAll,
+        mentionedBot: message.mentionedBot,
+        createTime: message.createTime,
+        ...(message.rootId === undefined ? {} : { rootId: message.rootId }),
+        ...(message.threadId === undefined ? {} : { threadId: message.threadId }),
+        ...(message.replyToMessageId === undefined ? {} : { replyToMessageId: message.replyToMessageId }),
+    };
+}
+function providerError(result) {
+    const classified = providerFailureCode(result.code);
+    if (classified === 'permission_denied') {
+        return new LarkTransportError('permission_denied', 'Lark rejected the application credential or permission');
+    }
+    if (classified === 'rate_limited' || /rate|frequency|too many/iu.test(result.msg ?? '')) {
+        return new LarkTransportError('rate_limited', 'Lark rate limited the message');
+    }
+    if (classified === 'format_error') {
+        return new LarkTransportError('format_error', 'Lark rejected the message card format');
+    }
+    return new LarkTransportError('unknown', `Lark rejected the message with code ${String(result.code ?? 'missing')}`);
+}
+export class OfficialLarkTransport {
+    client;
+    imageClient;
+    dispatcher;
+    ws;
+    handshakeTimeoutMs;
+    imageDownloadTimeoutMs;
+    lifecycleController = new AbortController();
+    handlers;
+    identity;
+    pendingHandshake;
+    constructor(options) {
+        const domain = options.domain === 'lark' ? Domain.Lark : Domain.Feishu;
+        const shared = { appId: options.appId, appSecret: options.appSecret, domain,
+            logger: silentLogger, loggerLevel: LoggerLevel.error, source: 'dsh-enhanced-lark-channel' };
+        this.handshakeTimeoutMs = options.handshakeTimeoutMs;
+        this.imageDownloadTimeoutMs = options.imageDownloadTimeoutMs;
+        this.client = new Client({ ...shared, appType: AppType.SelfBuild });
+        this.imageClient = new Client({
+            ...shared,
+            appType: AppType.SelfBuild,
+            httpInstance: boundedImageHttpInstance(options.imageDownloadTimeoutMs, this.lifecycleController.signal),
+        });
+        this.dispatcher = new EventDispatcher({ logger: silentLogger, loggerLevel: LoggerLevel.error });
+        this.dispatcher.register({
+            'im.message.receive_v1': async (raw) => {
+                if (this.handlers === undefined || this.identity === undefined)
+                    return;
+                const message = await normalize(raw, {
+                    botIdentity: this.identity,
+                    stripBotMentions: true,
+                });
+                await this.handlers.message(toSafeLarkMessage(message));
+            },
+            'card.action.trigger': async (raw) => {
+                if (this.handlers === undefined)
+                    return;
+                const action = normalizeCardAction(raw);
+                if (action === null)
+                    return;
+                return await this.handlers.cardAction({
+                    messageId: action.messageId,
+                    chatId: action.chatId,
+                    operatorId: action.operator.openId,
+                    value: action.action.value,
+                    tag: action.action.tag,
+                    ...(action.action.name === undefined ? {} : { name: action.action.name }),
+                    ...(action.action.option === undefined ? {} : { option: action.action.option }),
+                });
+            },
+        });
+        this.ws = new WSClient({
+            ...shared,
+            autoReconnect: true,
+            handshakeTimeoutMs: options.handshakeTimeoutMs,
+            onReady: () => this.pendingHandshake?.resolve(),
+            onError: error => {
+                const normalized = new LarkTransportError('not_connected', 'Lark WebSocket connection failed');
+                if (this.pendingHandshake !== undefined)
+                    this.pendingHandshake.reject(normalized);
+                else
+                    this.handlers?.error(normalized);
+                void error;
+            },
+            onReconnecting: () => this.handlers?.reconnecting(),
+            onReconnected: () => this.handlers?.reconnected(),
+        });
+        installLarkCardCallbackBridge(this.ws);
+    }
+    subscribe(handlers) {
+        if (this.handlers !== undefined)
+            throw new Error('lark-channel: transport is already subscribed');
+        this.handlers = handlers;
+        return () => { if (this.handlers === handlers)
+            this.handlers = undefined; };
+    }
+    async connect() {
+        this.identity = await this.fetchBotIdentity();
+        await new Promise((resolve, reject) => {
+            let settled = false;
+            const timer = setTimeout(() => {
+                if (settled)
+                    return;
+                settled = true;
+                this.pendingHandshake = undefined;
+                this.ws.close({ force: true });
+                reject(new LarkTransportError('not_connected', 'Lark WebSocket handshake timed out'));
+            }, this.handshakeTimeoutMs + 1_000);
+            timer.unref?.();
+            this.pendingHandshake = {
+                resolve: () => {
+                    if (settled)
+                        return;
+                    settled = true;
+                    clearTimeout(timer);
+                    this.pendingHandshake = undefined;
+                    resolve();
+                },
+                reject: error => {
+                    if (settled)
+                        return;
+                    settled = true;
+                    clearTimeout(timer);
+                    this.pendingHandshake = undefined;
+                    reject(error);
+                },
+            };
+            void this.ws.start({ eventDispatcher: this.dispatcher }).catch(error => {
+                void error;
+                this.pendingHandshake?.reject(new LarkTransportError('not_connected', 'Lark WebSocket startup failed'));
+            });
+        });
+    }
+    async disconnect() {
+        this.lifecycleController.abort(new Error('lark-channel: transport stopped'));
+        this.pendingHandshake?.reject(new LarkTransportError('not_connected', 'Lark transport stopped'));
+        this.ws.close({ force: true });
+    }
+    async downloadMessageImage(messageId, fileKey, options) {
+        const timeoutSignal = AbortSignal.timeout(this.imageDownloadTimeoutMs);
+        const signal = AbortSignal.any([options.signal, timeoutSignal, this.lifecycleController.signal]);
+        let response;
+        try {
+            response = await awaitImageResourceRequest(signal, async () => await this.imageClient.request(createLarkImageResourceRequest(messageId, fileKey, {
+                maxBytes: options.maxBytes, timeoutMs: this.imageDownloadTimeoutMs, signal,
+            })));
+        }
+        catch (error) {
+            if (options.signal.aborted) {
+                throw new LarkTransportError('not_connected', 'Lark image resource request was cancelled');
+            }
+            if (this.lifecycleController.signal.aborted) {
+                throw new LarkTransportError('not_connected', 'Lark image resource request was cancelled');
+            }
+            if (timeoutSignal.aborted) {
+                throw new LarkTransportError('send_timeout', 'Lark image resource request timed out');
+            }
+            const classified = await classifyLarkImageSdkFailure(error, signal);
+            if (options.signal.aborted || this.lifecycleController.signal.aborted) {
+                throw new LarkTransportError('not_connected', 'Lark image resource request was cancelled');
+            }
+            if (timeoutSignal.aborted) {
+                throw new LarkTransportError('send_timeout', 'Lark image resource request timed out');
+            }
+            throw new LarkTransportError(classified.code, 'Lark image resource request failed', classified.retryAfterMs);
+        }
+        try {
+            const image = await readLarkImageResourceResponse(response, { maxBytes: options.maxBytes, signal });
+            if (options.signal.aborted || this.lifecycleController.signal.aborted) {
+                throw new LarkTransportError('not_connected', 'Lark image resource request was cancelled');
+            }
+            if (timeoutSignal.aborted) {
+                throw new LarkTransportError('send_timeout', 'Lark image resource request timed out');
+            }
+            return image;
+        }
+        catch (error) {
+            if (options.signal.aborted) {
+                throw new LarkTransportError('not_connected', 'Lark image resource request was cancelled');
+            }
+            if (this.lifecycleController.signal.aborted) {
+                throw new LarkTransportError('not_connected', 'Lark image resource request was cancelled');
+            }
+            if (timeoutSignal.aborted) {
+                throw new LarkTransportError('send_timeout', 'Lark image resource request timed out');
+            }
+            const classified = error instanceof LarkImageResponseValidationError
+                ? { code: 'format_error' }
+                : classifyLarkSdkFailure(error);
+            const message = classified.code === 'format_error'
+                ? 'Lark image resource response failed validation'
+                : 'Lark image resource response could not be read';
+            throw new LarkTransportError(classified.code, message, classified.retryAfterMs);
+        }
+    }
+    async addReaction(messageId, emojiType) {
+        try {
+            const response = await this.client.im.v1.messageReaction.create({
+                path: { message_id: messageId },
+                data: { reaction_type: { emoji_type: emojiType } },
+            });
+            if (response.code !== undefined && response.code !== 0) {
+                throw providerError({ code: response.code, msg: response.msg });
+            }
+            const reactionId = response.data?.reaction_id;
+            if (reactionId === undefined || reactionId === '') {
+                throw new LarkTransportError('unknown', 'Lark accepted reaction omitted reaction identity');
+            }
+            return reactionId;
+        }
+        catch (error) {
+            if (error instanceof LarkTransportError)
+                throw error;
+            const classified = classifyLarkSdkFailure(error);
+            throw new LarkTransportError(classified.code, 'Lark reaction request failed', classified.retryAfterMs);
+        }
+    }
+    async createProgress(chatId, options) {
+        try {
+            const response = await this.client.request(createLarkProgressRequest(chatId, options));
+            if (response.code !== undefined && response.code !== 0) {
+                throw providerError({ code: response.code, msg: response.msg });
+            }
+            const cotId = response.data?.cot_id;
+            const messageId = response.data?.message_id;
+            if (cotId === undefined || messageId === undefined) {
+                throw new LarkTransportError('unknown', 'Lark accepted progress request omitted progress identity');
+            }
+            return { cotId, messageId };
+        }
+        catch (error) {
+            if (error instanceof LarkTransportError)
+                throw error;
+            const classified = classifyLarkSdkFailure(error);
+            throw new LarkTransportError(classified.code, 'Lark progress request failed', classified.retryAfterMs);
+        }
+    }
+    async writeProgress(handle, events) {
+        try {
+            const response = await this.client.request(writeLarkProgressRequest(handle, events));
+            if (response.code !== undefined && response.code !== 0) {
+                throw providerError({ code: response.code, msg: response.msg });
+            }
+        }
+        catch (error) {
+            if (error instanceof LarkTransportError)
+                throw error;
+            const classified = classifyLarkSdkFailure(error);
+            throw new LarkTransportError(classified.code, 'Lark progress update failed', classified.retryAfterMs);
+        }
+    }
+    async send(chatId, input, options = {}) {
+        const rendered = renderLarkMessage(input);
+        const uuid = larkRequestUuid(options.requestKey ?? `${chatId}:${rendered.content}`);
+        try {
+            const response = options.replyTo === undefined
+                ? await this.client.im.v1.message.create({
+                    params: { receive_id_type: 'chat_id' },
+                    data: { receive_id: chatId, msg_type: rendered.msgType, content: rendered.content, uuid },
+                })
+                : await this.client.im.v1.message.reply({
+                    path: { message_id: options.replyTo },
+                    data: { msg_type: rendered.msgType, content: rendered.content, uuid,
+                        ...(options.replyInThread === undefined ? {} : { reply_in_thread: options.replyInThread }) },
+                });
+            if (response.code !== 0)
+                throw providerError({ code: response.code, msg: response.msg });
+            const messageId = response.data?.message_id;
+            if (messageId === undefined)
+                throw new LarkTransportError('unknown', 'Lark accepted response omitted message identity');
+            return { messageId };
+        }
+        catch (error) {
+            if (error instanceof LarkTransportError)
+                throw error;
+            const classified = classifyLarkSdkFailure(error);
+            throw new LarkTransportError(classified.code, 'Lark SDK request failed', classified.retryAfterMs);
+        }
+    }
+    async fetchBotIdentity() {
+        try {
+            const response = await this.client.request({
+                url: '/open-apis/bot/v3/info', method: 'GET',
+            });
+            if (response.bot?.open_id === undefined) {
+                throw new LarkTransportError('permission_denied', 'Lark bot identity is unavailable');
+            }
+            return { openId: response.bot.open_id, name: response.bot.app_name ?? 'bot' };
+        }
+        catch (error) {
+            if (error instanceof LarkTransportError)
+                throw error;
+            const classified = classifyLarkSdkFailure(error);
+            throw new LarkTransportError(classified.code, 'Lark bot identity request failed', classified.retryAfterMs);
+        }
+    }
+}
+export function createOfficialLarkTransport(options) {
+    return new OfficialLarkTransport(options);
+}
+//# sourceMappingURL=sdk.js.map