@kafca/agentdock 0.1.56 → 0.1.58

package/dist-electron/services/local-ai-core/src/channel/lark/outbound-transport.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LarkOutboundTransport = void 0;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const file_utils_js_1 = require("../shared/file-utils.js");
+const cards_js_1 = require("./cards.js");
+const messages_js_1 = require("./rendering/messages.js");
+const LARK_MAX_UPLOAD_FILE_SIZE = 30 * 1024 * 1024;
+class LarkOutboundTransport {
+    log;
+    constructor(log) {
+        this.log = log;
+    }
+    async sendFilePart(state, channelId, part) {
+        const file = await (0, file_utils_js_1.prepareChannelFile)({
+            path: part.path,
+            fileName: part.fileName,
+            workspacePath: typeof part.metadata?.workspacePath === 'string' ? part.metadata.workspacePath : undefined,
+            maxBytes: LARK_MAX_UPLOAD_FILE_SIZE,
+            platformLabel: 'Lark',
+        });
+        const upload = await state.client.im.file.create({
+            data: {
+                file_type: resolveLarkUploadFileType(file.fileName),
+                file_name: file.fileName,
+                file: (0, node_fs_1.createReadStream)(file.path),
+            },
+        });
+        const fileKey = String(upload?.file_key || upload?.data?.file_key || '').trim();
+        if (!fileKey) {
+            throw new Error('Lark file upload did not return a file key');
+        }
+        const response = await state.client.im.message.create({
+            params: {
+                receive_id_type: resolveReceiveIdType(channelId),
+            },
+            data: {
+                receive_id: channelId,
+                msg_type: 'file',
+                content: JSON.stringify({ file_key: fileKey }),
+            },
+        });
+        const messageId = String(response?.data?.message_id || '').trim();
+        if (!messageId) {
+            throw new Error('Lark file message did not return a message id');
+        }
+        this.log?.(`localcore-lark sent file ${file.fileName} (${file.fileSize} bytes) to ${channelId}`);
+        return { messageId, fileKey, file };
+    }
+    async sendTextAsCard(state, chatId, text, buttonRows = [], sessionKey, threadId) {
+        return this.timed('card create', '', text, () => this.createMessage(state, chatId, 'interactive', (0, cards_js_1.buildInteractiveCard)(text, buttonRows, sessionKey, threadId)));
+    }
+    async sendSessionCommandCard(state, chatId, text, actionRows, sessionKey, threadId) {
+        return this.timed('session card create', '', text, () => this.createMessage(state, chatId, 'interactive', (0, cards_js_1.buildSessionCommandCard)(text, actionRows, sessionKey, threadId)));
+    }
+    async sendTextAsMessage(state, chatId, text) {
+        const rendered = (0, messages_js_1.renderLarkTextMessage)(text);
+        const messageId = await this.timed(`${rendered.renderKind} create`, `msgType=${rendered.msgType} reason=${rendered.reason} tableCount=${rendered.tableCount}`, text, () => this.createMessage(state, chatId, rendered.msgType, rendered.content));
+        return {
+            messageId,
+            renderKind: rendered.renderKind,
+            msgType: rendered.msgType,
+        };
+    }
+    async patchTextCard(state, messageId, text, buttonRows = [], sessionKey, threadId) {
+        await this.timed('card patch', `message=${messageId}`, text, async () => {
+            await state.client.im.message.patch({
+                path: { message_id: messageId },
+                data: { content: JSON.stringify((0, cards_js_1.buildInteractiveCard)(text, buttonRows, sessionKey, threadId)) },
+            });
+        });
+    }
+    async createMessage(state, chatId, msgType, content) {
+        const response = await state.client.im.message.create({
+            params: { receive_id_type: resolveReceiveIdType(chatId) },
+            data: {
+                receive_id: chatId,
+                msg_type: msgType,
+                content: JSON.stringify(content),
+            },
+        });
+        return String(response?.data?.message_id || '').trim();
+    }
+    async timed(label, fields, text, action) {
+        const startedAt = Date.now();
+        const result = await action();
+        this.log?.(`localcore-lark ${label} took ${Date.now() - startedAt}ms${fields ? ` ${fields}` : ''} textBytes=${Buffer.byteLength(text || '', 'utf8')}`);
+        return result;
+    }
+}
+exports.LarkOutboundTransport = LarkOutboundTransport;
+function resolveReceiveIdType(receiveId) {
+    return receiveId.startsWith('oc_') ? 'chat_id' : receiveId.startsWith('ou_') ? 'open_id' : 'user_id';
+}
+function resolveLarkUploadFileType(fileName) {
+    switch ((0, node_path_1.extname)(fileName).toLowerCase()) {
+        case '.opus': return 'opus';
+        case '.mp4':
+        case '.mov':
+        case '.m4v': return 'mp4';
+        case '.pdf': return 'pdf';
+        case '.doc':
+        case '.docx': return 'doc';
+        case '.xls':
+        case '.xlsx':
+        case '.csv': return 'xls';
+        case '.ppt':
+        case '.pptx': return 'ppt';
+        default: return 'stream';
+    }
+}

package/dist-electron/services/local-ai-core/src/channel/lark/runtime-state.js

@@ -9,6 +9,7 @@ exports.renderLarkBridgeEventMessage = renderLarkBridgeEventMessage;
 exports.renderLarkBridgeEventMessages = renderLarkBridgeEventMessages;
 exports.getLarkRenderedMessageId = getLarkRenderedMessageId;
 exports.setLarkRenderedMessageId = setLarkRenderedMessageId;
+const bridge_event_helpers_js_1 = require("../shared/bridge-event-helpers.js");
 function createLarkTurnState(sessionKey, sourceMessageId) {
     const turn = {
         sessionKey,
@@ -49,7 +50,7 @@ function isPendingToolProgressForLark(event) {
 }
 function consumeLarkBridgeEvent(turn, event, options) {
     const content = foldToolResultForLark(String(event.content || '').trim());
-    const bridgeKind = resolveBridgeEventKind(event);
+    const bridgeKind = (0, bridge_event_helpers_js_1.resolveBridgeEventKind)(event);
     if (event.type === 'typing_start') {
         turn.messageId = undefined;
         turn.finalMessageId = undefined;
@@ -123,7 +124,7 @@ function consumeLarkBridgeEvent(turn, event, options) {
 }
 function renderLarkBridgeEventMessage(turn, event) {
     const content = foldToolResultForLark(String(event.content || '').trim());
-    const bridgeKind = resolveBridgeEventKind(event);
+    const bridgeKind = (0, bridge_event_helpers_js_1.resolveBridgeEventKind)(event);
     if (event.type === 'preview_start' || event.type === 'update_message') {
         if (bridgeKind === 'thought') {
             return { key: 'noop', text: '', buttonRows: [], isFinal: false };
@@ -240,15 +241,9 @@ function progressKey(prefix, event) {
     return `${prefix}:${content.slice(0, 120)}`;
 }
 function isThoughtBridgeEvent(event) {
-    const kind = resolveBridgeEventKind(event);
+    const kind = (0, bridge_event_helpers_js_1.resolveBridgeEventKind)(event);
     return kind === 'thought' || kind === 'plan';
 }
-function resolveBridgeEventKind(event) {
-    if (event.bridgeKind) {
-        return event.bridgeKind;
-    }
-    return event.type === 'status' ? 'status' : 'assistant';
-}
 function renderProcessText(kind, content) {
     const text = content.trim();
     return kind === 'plan' ? `计划\n${text}` : text;
@@ -279,15 +274,5 @@ function fencedCode(value, language = '') {
     return `${fence}${language}\n${normalized}\n${fence}`;
 }
 function pushUniqueLarkTurnLine(target, value) {
-    const normalized = value.trim();
-    if (!normalized) {
-        return;
-    }
-    if (target[target.length - 1] === normalized) {
-        return;
-    }
-    target.push(normalized);
-    if (target.length > 6) {
-        target.splice(0, target.length - 6);
-    }
+    (0, bridge_event_helpers_js_1.pushUniqueLine)(target, value, 6);
 }

package/dist-electron/services/local-ai-core/src/channel/shared/base-channel-gateway.js

@@ -232,6 +232,30 @@ class BaseChannelGateway extends node_events_1.EventEmitter {
     async executeSessionCommand(input) {
         return this.sessionCommandRuntime.execute(input);
     }
+    async resolveDefaultAgentType(workspaceId, threadId) {
+        const router = this.options.getWorkspaceRouter();
+        if (typeof router.getWorkspaceDefaultAgentType === 'function') {
+            return router.getWorkspaceDefaultAgentType(workspaceId);
+        }
+        return this.options.store.getThreadRow(threadId)?.agent_type || 'codex';
+    }
+    findAwaitingPermissionThreadId(workspaceId, chatId, platformUserId, platformKey) {
+        for (const [sessionKey, route] of this.threadRouting.entries()) {
+            if (route.workspaceId !== workspaceId
+                || route.chatId !== chatId
+                || route.platformUserId !== platformUserId) {
+                continue;
+            }
+            if (platformKey !== undefined && route.platformKey !== platformKey) {
+                continue;
+            }
+            const turn = this.outboundTurns.get(sessionKey);
+            if (turn?.awaitingPermission && route.threadId) {
+                return route.threadId;
+            }
+        }
+        return '';
+    }
     // ==================== Runtime Management ====================
     resolveRuntimeState(workspaceId, instanceId) {
         const key = resolveRuntimeKey(workspaceId, instanceId);
@@ -280,6 +304,19 @@ class BaseChannelGateway extends node_events_1.EventEmitter {
             },
         });
     }
+    scheduleOutboundChain(sessionKey, work) {
+        const previous = this.outboundEventChains.get(sessionKey) || Promise.resolve();
+        const current = previous
+            .catch(() => undefined)
+            .then(work)
+            .finally(() => {
+            if (this.outboundEventChains.get(sessionKey) === current) {
+                this.outboundEventChains.delete(sessionKey);
+            }
+        });
+        this.outboundEventChains.set(sessionKey, current);
+        return current;
+    }
     clearRuntimeError(state) {
         state.lastError = undefined;
         state.lastErrorInfo = undefined;

package/dist-electron/services/local-ai-core/src/channel/shared/bridge-event-helpers.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveBridgeEventKind = resolveBridgeEventKind;
+exports.pushUniqueLine = pushUniqueLine;
+function resolveBridgeEventKind(event) {
+    if (event.bridgeKind) {
+        return event.bridgeKind;
+    }
+    return event.type === 'status' ? 'status' : 'assistant';
+}
+function pushUniqueLine(target, value, maxLines) {
+    const normalized = value.trim();
+    if (!normalized) {
+        return;
+    }
+    if (target[target.length - 1] === normalized) {
+        return;
+    }
+    target.push(normalized);
+    if (target.length > maxLines) {
+        target.splice(0, target.length - maxLines);
+    }
+}

package/dist-electron/services/local-ai-core/src/channel/shared/channel-keys.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.normalizeChannelInstanceId = normalizeChannelInstanceId;
 exports.channelPlatformKey = channelPlatformKey;
+exports.extractChannelInstanceId = extractChannelInstanceId;
 exports.runtimeKey = runtimeKey;
 function normalizeChannelInstanceId(value, fallback) {
     const raw = String(value || '').trim();
@@ -11,6 +12,11 @@ function normalizeChannelInstanceId(value, fallback) {
 function channelPlatformKey(platform, instanceId) {
     return instanceId === 'default' ? platform : `${platform}:${instanceId}`;
 }
+function extractChannelInstanceId(platform, prefix) {
+    const normalized = String(platform || '').trim();
+    const tag = `${prefix}:`;
+    return normalized.startsWith(tag) ? normalized.slice(tag.length).trim() : '';
+}
 function runtimeKey(workspaceId, instanceId) {
     return `${workspaceId}::${instanceId}`;
 }

package/dist-electron/services/local-ai-core/src/channel/shared/inbound-authorization.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveInboundChannelAuthorization = resolveInboundChannelAuthorization;
+const node_crypto_1 = require("node:crypto");
+const DEFAULT_PAIRING_EXPIRY_MS = 10 * 60 * 1000;
+function resolveInboundChannelAuthorization(input) {
+    const { store, identity } = input;
+    store.expirePendingPairings();
+    let authorized = store.getAuthorizedUser(identity.workspaceId, identity.platformUserId, identity.platformKey);
+    let autoApproved = false;
+    if (!authorized && input.autoApprove) {
+        const authorizedAt = (input.now?.() || new Date()).toISOString();
+        store.createAuthorizedUser({
+            id: `${input.authorizedUserIdPrefix}-${(0, node_crypto_1.randomUUID)()}`,
+            workspace_id: identity.workspaceId,
+            platform: identity.platformKey,
+            platform_user_id: identity.platformUserId,
+            chat_id: identity.chatId,
+            display_name: identity.displayName,
+            thread_id: null,
+            authorized_at: authorizedAt,
+        });
+        authorized = store.getAuthorizedUser(identity.workspaceId, identity.platformUserId, identity.platformKey);
+        autoApproved = Boolean(authorized);
+        if (autoApproved) {
+            input.onStateChanged?.();
+        }
+    }
+    if (authorized) {
+        return { status: 'authorized', authorized, autoApproved };
+    }
+    const existingPending = store.listPendingPairings(identity.workspaceId).find((item) => item.platform === identity.platformKey &&
+        item.platform_user_id === identity.platformUserId &&
+        item.chat_id === identity.chatId &&
+        item.status === 'pending');
+    if (existingPending) {
+        return { status: 'pending', pairingCode: existingPending.code };
+    }
+    const now = input.now?.() || new Date();
+    const pairingCode = input.generatePairingCode();
+    store.createPairingRequest({
+        code: pairingCode,
+        workspace_id: identity.workspaceId,
+        platform: identity.platformKey,
+        platform_user_id: identity.platformUserId,
+        chat_id: identity.chatId,
+        display_name: identity.displayName,
+        requested_at: now.toISOString(),
+        expires_at: new Date(now.getTime() + (input.pairingExpiryMs || DEFAULT_PAIRING_EXPIRY_MS)).toISOString(),
+        status: 'pending',
+    });
+    input.onStateChanged?.();
+    return { status: 'pending', pairingCode };
+}

package/dist-electron/services/local-ai-core/src/channel/weixin/config.js

@@ -15,7 +15,7 @@ exports.saveWeixinBuf = saveWeixinBuf;
 exports.collectWeixinWorkspaceBindings = collectWeixinWorkspaceBindings;
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
-const desktop_js_1 = require("../../../../../shared/desktop.js");
+const superai_contracts_1 = require("../../../../../packages/contracts/src/index.js");
 const channel_keys_js_1 = require("../shared/channel-keys.js");
 exports.DEFAULT_BASE_URL = 'https://ilinkai.weixin.qq.com';
 exports.DEFAULT_CDN_BASE_URL = 'https://novac2c.cdn.weixin.qq.com/c2c';
@@ -75,7 +75,7 @@ function collectWeixinWorkspaceBindings(config) {
         const platforms = Array.isArray(project.platforms) ? project.platforms : [];
         return platforms
             .map((platform) => ({
-            platformType: (0, desktop_js_1.normalizeDesktopPlatformType)(platform?.type),
+            platformType: (0, superai_contracts_1.normalizeDesktopPlatformType)(platform?.type),
             options: platform?.options && typeof platform.options === 'object'
                 ? platform.options
                 : {},

package/dist-electron/services/local-ai-core/src/channel/weixin/inbound-media.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createWeixinAttachmentContentPart = createWeixinAttachmentContentPart;
+function createWeixinAttachmentContentPart(att) {
+    if (att.kind === 'image') {
+        if (!att.data)
+            return null;
+        return {
+            type: 'image',
+            data: att.data,
+            ...(att.uri ? { uri: att.uri } : {}),
+            mimeType: att.mimeType,
+            fileName: att.name,
+        };
+    }
+    return {
+        type: 'file',
+        path: att.path,
+        fileName: att.name,
+    };
+}

package/dist-electron/services/local-ai-core/src/channel/weixin/inbound-poller.js

@@ -0,0 +1,167 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runWeixinInboundPoller = runWeixinInboundPoller;
+const node_path_1 = require("node:path");
+const local_core_errors_js_1 = require("../../kernel/local-core-errors.js");
+const config_js_1 = require("./config.js");
+const transport_js_1 = require("./transport.js");
+const text_utils_js_1 = require("./text-utils.js");
+const inbound_media_js_1 = require("./inbound-media.js");
+const RETRY_DELAY_MS = 2_000;
+const MAX_CONSECUTIVE_FAILURES = 3;
+const ERROR_LOG_WINDOW_MS = 5 * 60 * 1000;
+function computeRetryDelay(failures) {
+    if (failures <= 1)
+        return RETRY_DELAY_MS;
+    if (failures === 2)
+        return 5_000;
+    if (failures === 3)
+        return 15_000;
+    if (failures === 4)
+        return 30_000;
+    return 60_000;
+}
+async function runWeixinInboundPoller(input) {
+    const { binding, signal } = input;
+    const errorLogWindows = new Map();
+    let buf = (0, config_js_1.loadWeixinBuf)(binding);
+    let consecutiveFailures = 0;
+    const logPollError = (errorKey, message) => {
+        const key = `${binding.workspaceId}:${binding.instanceId}`;
+        const now = Date.now();
+        const current = errorLogWindows.get(key);
+        if (!current || current.errorKey !== errorKey || now - current.at >= ERROR_LOG_WINDOW_MS) {
+            input.log?.(current?.count && current.count > 1 ? `${message} (repeated ${current.count} times)` : message);
+            errorLogWindows.set(key, { at: now, count: 1, errorKey });
+            return;
+        }
+        current.count += 1;
+        errorLogWindows.set(key, current);
+    };
+    while (!signal.aborted) {
+        try {
+            const resp = await (0, transport_js_1.getWeixinUpdates)(binding, buf, signal);
+            const isApiError = (resp.ret !== undefined && resp.ret !== 0) || (resp.errcode !== undefined && resp.errcode !== 0);
+            if (isApiError) {
+                consecutiveFailures += 1;
+                const state = input.getRuntimeState();
+                const retryDelayMs = computeRetryDelay(consecutiveFailures);
+                if (resp.errcode === -14 || resp.ret === -14) {
+                    if (state) {
+                        state.status = 'error';
+                        state.connected = false;
+                        state.consecutiveFailures = consecutiveFailures;
+                        state.nextRetryAt = new Date(Date.now() + retryDelayMs).toISOString();
+                        input.setRuntimeError(state, (0, local_core_errors_js_1.toLocalCoreErrorInfo)(new local_core_errors_js_1.LocalCoreError('channel_session_expired', 'WeChat login expired.')));
+                        input.notifyRuntimeStateChanged();
+                    }
+                }
+                logPollError(`ret=${resp.ret} errcode=${resp.errcode} errmsg=${resp.errmsg || ''}`, `localcore-weixin getUpdates failed for ${binding.workspaceId}: ret=${resp.ret} errcode=${resp.errcode}${resp.errmsg ? ` errmsg=${resp.errmsg}` : ''} (${consecutiveFailures})`);
+                if (state && resp.errcode !== -14 && resp.ret !== -14) {
+                    state.consecutiveFailures = consecutiveFailures;
+                    state.nextRetryAt = new Date(Date.now() + retryDelayMs).toISOString();
+                }
+                await (0, text_utils_js_1.waitForWeixinRetry)(retryDelayMs, signal);
+                if (consecutiveFailures >= MAX_CONSECUTIVE_FAILURES) {
+                    consecutiveFailures = MAX_CONSECUTIVE_FAILURES;
+                }
+                continue;
+            }
+            consecutiveFailures = 0;
+            const state = input.getRuntimeState();
+            if (state) {
+                input.clearRuntimeError(state);
+                state.status = 'running';
+                state.connected = true;
+                input.notifyRuntimeStateChanged();
+            }
+            if (resp.get_updates_buf) {
+                buf = resp.get_updates_buf;
+                (0, config_js_1.saveWeixinBuf)(binding, buf);
+            }
+            for (const msg of resp.msgs ?? []) {
+                const items = msg.item_list ?? [];
+                const textItem = items.find((item) => item.type === transport_js_1.TEXT_ITEM_TYPE);
+                const voiceTextItems = items.filter((item) => item.type === transport_js_1.VOICE_ITEM_TYPE && item.voice_item?.text);
+                const mediaItems = items.filter((item) => item.type === transport_js_1.IMAGE_ITEM_TYPE || item.type === transport_js_1.FILE_ITEM_TYPE);
+                if (!textItem && voiceTextItems.length === 0 && mediaItems.length === 0)
+                    continue;
+                const conversationId = msg.from_user_id ?? '';
+                const text = [textItem?.text_item?.text?.trim(), ...voiceTextItems.map((item) => item.voice_item?.text?.trim())]
+                    .filter((part) => Boolean(part))
+                    .join('\n\n');
+                const msgId = msg.msg_id ?? String(Date.now());
+                let attachmentText = '';
+                const attachmentParts = [];
+                if (mediaItems.length > 0) {
+                    const uploadsDir = (0, node_path_1.join)(binding.stateDir, 'weixin-uploads');
+                    const mayMaterializeAttachments = binding.allowFrom === '*' || Boolean(input.getAuthorizedUser(binding.workspaceId, conversationId, binding.platformKey));
+                    if (!mayMaterializeAttachments) {
+                        for (const item of mediaItems) {
+                            const itemData = item.image_item ?? item.file_item ?? null;
+                            const declaredName = String(itemData?.file_name ?? (item.type === transport_js_1.IMAGE_ITEM_TYPE ? 'image' : 'file'));
+                            attachmentText += attachmentText ? '\n' : '';
+                            attachmentText += item.type === transport_js_1.IMAGE_ITEM_TYPE ? '[Image]' : `[File: ${declaredName}]`;
+                        }
+                    }
+                    else {
+                        const downloads = await Promise.all(mediaItems.map(async (item, index) => {
+                            try {
+                                return await input.downloadMediaItem(item, msgId, index, uploadsDir, binding);
+                            }
+                            catch (error) {
+                                input.log?.(`localcore-weixin attachment download failed (${conversationId}#${index}): ${(0, local_core_errors_js_1.formatSafeError)(error)}`);
+                                return null;
+                            }
+                        }));
+                        for (const attachment of downloads) {
+                            if (!attachment) {
+                                continue;
+                            }
+                            attachmentText += attachmentText ? '\n' : '';
+                            attachmentText += attachment.kind === 'image'
+                                ? `[Image: ${attachment.path}]`
+                                : `[File "${attachment.name}": ${attachment.path}]`;
+                            const part = (0, inbound_media_js_1.createWeixinAttachmentContentPart)(attachment);
+                            if (part)
+                                attachmentParts.push(part);
+                        }
+                    }
+                }
+                const fullText = [text, attachmentText].filter(Boolean).join('\n\n');
+                if (!fullText)
+                    continue;
+                await input.handleInboundMessage({
+                    workspaceId: binding.workspaceId,
+                    instanceId: binding.instanceId,
+                    platformKey: binding.platformKey,
+                    platformUserId: conversationId,
+                    chatId: conversationId,
+                    displayName: conversationId.slice(-6),
+                    text: fullText,
+                    messageId: msgId,
+                    contextToken: msg.context_token,
+                    contentParts: [
+                        ...(text ? [{ type: 'text', text }] : []),
+                        ...attachmentParts,
+                    ],
+                });
+            }
+        }
+        catch (error) {
+            if (signal.aborted)
+                return;
+            consecutiveFailures += 1;
+            const retryDelayMs = computeRetryDelay(consecutiveFailures);
+            const state = input.getRuntimeState();
+            if (state) {
+                state.consecutiveFailures = consecutiveFailures;
+                state.nextRetryAt = new Date(Date.now() + retryDelayMs).toISOString();
+                input.setRuntimeError(state, (0, local_core_errors_js_1.toLocalCoreErrorInfo)(error));
+                input.notifyRuntimeStateChanged();
+            }
+            logPollError((0, local_core_errors_js_1.formatSafeError)(error), `localcore-weixin getUpdates error for ${binding.workspaceId} (${consecutiveFailures}): ${(0, local_core_errors_js_1.formatSafeError)(error)}`);
+            await (0, text_utils_js_1.waitForWeixinRetry)(retryDelayMs, signal);
+        }
+    }
+}