maka-agent 0.2.1-dev.91.20261018 → 0.2.2-dev.97.20261024

package/node_modules/@maka/runtime/dist/bots/feishu-bridge.js

@@ -16,9 +16,23 @@
  * specific language governing permissions and limitations
  * under the License.
  */
+import { createHash } from 'node:crypto';
 import { createRequire } from 'node:module';
 import { BaseBotAdapter, botReadinessFromSettings } from './base-adapter.js';
 const HANDSHAKE_TIMEOUT_MS = 15_000;
+/** Bound network requests only; this does not limit Agent execution time. */
+export function feishuHttpTransport(base) {
+    return {
+        ...base,
+        request(options) {
+            const auxiliary = /\/(reactions|read_users)(?:\/|$)/.test(options.url ?? '');
+            return base.request({
+                ...options,
+                timeout: options.timeout ?? (auxiliary ? 3_000 : 15_000),
+            });
+        },
+    };
+}
 /**
  * `LarkChannel.disconnect()` is a no-op until its first handshake marks the
  * channel connected. Close the raw socket first so a failed or cancelled
@@ -34,26 +48,89 @@ export async function closeLarkChannel(channel) {
     await channel.disconnect().catch(() => { });
 }
 export function feishuMessageToEvent(message, receivedAt) {
-    if (!message.content.trim() || !message.senderId || !message.chatId)
+    const resource = message.resources?.[0];
+    const mediaOnly = ['image', 'file', 'audio', 'media', 'sticker'].includes(message.rawContentType);
+    if ((!message.content.trim() && !resource) || !message.senderId || !message.chatId)
         return null;
+    const kinds = {
+        image: 'photo',
+        file: 'document',
+        audio: 'voice',
+        video: 'video',
+        sticker: 'sticker',
+    };
     return {
         platform: 'feishu',
         userId: message.senderId,
         userName: message.senderName ?? message.senderId,
         chatId: message.chatId,
         isGroup: message.chatType === 'group',
-        text: message.content,
+        text: mediaOnly ? '' : message.content,
         sourceMessageId: message.messageId,
         receivedAt,
+        ...(resource ? { attachmentKind: kinds[resource.type] } : {}),
     };
 }
+/** Only summaries use cards; ordinary replies use Markdown posts. Retry IDs stay stable. */
+export function feishuAssistantMessages(text, options) {
+    const chunks = [];
+    let chunk = '', bytes = 0;
+    for (const char of text) {
+        const size = Buffer.byteLength(JSON.stringify(char));
+        if (bytes + size > 12_000 && chunk) {
+            chunks.push(chunk);
+            chunk = '';
+            bytes = 0;
+        }
+        chunk += char;
+        bytes += size;
+    }
+    if (chunk || !chunks.length)
+        chunks.push(chunk);
+    return chunks.map((content, index) => {
+        const body = { tag: 'markdown', content };
+        const summary = options.summary?.trim();
+        // Oversize summaries fall back to the complete body, never truncated text.
+        const elements = summary && Buffer.byteLength(JSON.stringify(summary)) < 6_000
+            ? [
+                { tag: 'markdown', content: summary },
+                {
+                    tag: 'collapsible_panel',
+                    expanded: false,
+                    header: {
+                        title: {
+                            tag: 'plain_text',
+                            content: chunks.length > 1 ? `详情 ${index + 1}/${chunks.length}` : '详情',
+                        },
+                    },
+                    elements: [body],
+                },
+            ]
+            : [body];
+        return {
+            msg_type: summary ? 'interactive' : 'post',
+            content: JSON.stringify(summary
+                ? { schema: '2.0', body: { elements } }
+                : { zh_cn: { title: '', content: [[{ tag: 'md', text: content }]] } }),
+            uuid: createHash('sha256')
+                .update(`${options.clientMessageId}:${index}`)
+                .digest('hex')
+                .slice(0, 50),
+        };
+    });
+}
 /** Feishu/Lark long-connection bridge backed by the official Channel API. */
 export class FeishuBotBridge extends BaseBotAdapter {
+    loadSdk;
     channel = null;
     unsubscribe = [];
     explicitlyStopped = false;
-    constructor(settings) {
+    lastMessage = new Map();
+    reactions = new Map();
+    reactionQueue = Promise.resolve();
+    constructor(settings, loadSdk = () => createRequire(import.meta.url)('@larksuiteoapi/node-sdk')) {
         super('feishu', settings);
+        this.loadSdk = loadSdk;
     }
     async start() {
         if (this.running)
@@ -75,13 +152,15 @@ export class FeishuBotBridge extends BaseBotAdapter {
         let channel;
         try {
             // Keep lazy loading synchronous so stop() cannot race a module-loading await.
-            const { Domain, LoggerLevel, createLarkChannel } = createRequire(import.meta.url)('@larksuiteoapi/node-sdk');
+            const { Domain, LoggerLevel, createLarkChannel, defaultHttpInstance } = this.loadSdk();
             const isLark = this.settings.domain?.trim() === 'larksuite.com';
             channel = createLarkChannel({
                 appId,
                 appSecret,
                 domain: isLark ? Domain.Lark : Domain.Feishu,
                 transport: 'websocket',
+                // The SDK transport unwraps Axios responses in its response interceptor.
+                httpInstance: feishuHttpTransport(defaultHttpInstance),
                 source: 'maka',
                 loggerLevel: LoggerLevel.error,
                 handshakeTimeoutMs: HANDSHAKE_TIMEOUT_MS,
@@ -113,6 +192,9 @@ export class FeishuBotBridge extends BaseBotAdapter {
     async stop() {
         this.explicitlyStopped = true;
         this.running = false;
+        await this.reactionQueue;
+        await Promise.all([...this.reactions.keys()].map((chat) => this.cancelTypingIndicator(chat)));
+        this.lastMessage.clear();
         const channel = this.channel;
         this.channel = null;
         this.clearSubscriptions();
@@ -127,12 +209,34 @@ export class FeishuBotBridge extends BaseBotAdapter {
         if (!channel || !this.running || !chatId.trim())
             return null;
         try {
-            const result = await channel.send(chatId, { markdown: text }, options?.replyToMessageId ? { replyTo: options.replyToMessageId } : undefined);
+            let messageId;
+            if (options?.clientMessageId) {
+                let firstId;
+                for (const message of feishuAssistantMessages(text, options)) {
+                    const result = await channel.rawClient.im.v1.message.create({
+                        params: { receive_id_type: chatId.startsWith('ou_') ? 'open_id' : 'chat_id' },
+                        data: {
+                            receive_id: chatId,
+                            msg_type: message.msg_type,
+                            content: message.content,
+                            uuid: message.uuid,
+                        },
+                    });
+                    if (result.code !== 0 || !result.data?.message_id)
+                        throw Error(`Feishu send failed: ${result.code}`);
+                    firstId ??= result.data.message_id;
+                }
+                messageId = firstId;
+            }
+            else {
+                const result = await channel.send(chatId, { markdown: text }, options?.replyToMessageId ? { replyTo: options.replyToMessageId } : undefined);
+                messageId = result.messageId;
+            }
             this.readiness = 'operational';
             this.reason = undefined;
             this.lastEventAt = Date.now();
             this.emitStatusChange();
-            return result.messageId;
+            return messageId;
         }
         catch (error) {
             this.readiness = this.readiness === 'operational' ? 'degraded' : 'credentials_valid';
@@ -141,6 +245,61 @@ export class FeishuBotBridge extends BaseBotAdapter {
             return null;
         }
     }
+    /** Feishu has message reactions rather than a native chat typing API. */
+    sendTypingIndicator(chatId) {
+        return this.queueReaction(async () => {
+            const channel = this.channel;
+            const message = this.lastMessage.get(chatId);
+            if (!channel || !this.running || !message)
+                return false;
+            const current = this.reactions.get(chatId);
+            if (current?.message === message)
+                return true;
+            if (current) {
+                await channel.removeReaction(current.message, current.reaction);
+                this.reactions.delete(chatId);
+            }
+            const reaction = await channel.addReaction(message, 'Typing');
+            this.reactions.set(chatId, { message, reaction });
+            return true;
+        });
+    }
+    cancelTypingIndicator(chatId) {
+        return this.queueReaction(async () => {
+            const current = this.reactions.get(chatId);
+            if (!current)
+                return true;
+            if (!this.channel)
+                return false;
+            await this.channel.removeReaction(current.message, current.reaction);
+            this.reactions.delete(chatId);
+            return true;
+        });
+    }
+    queueReaction(work) {
+        const next = this.reactionQueue.then(work).catch(() => false);
+        this.reactionQueue = next;
+        return next;
+    }
+    async getMessageReadStatus(messageId, userId) {
+        if (!this.channel || !this.running)
+            return { state: 'unknown' };
+        try {
+            const result = await this.channel.rawClient.im.v1.message.readUsers({
+                path: { message_id: messageId },
+                params: { user_id_type: 'open_id', page_size: 100 },
+            });
+            if (result.code !== 0)
+                return { state: 'unknown' };
+            const user = result.data?.items?.find((entry) => entry.user_id === userId);
+            if (user)
+                return { state: 'read' };
+            return { state: result.data?.has_more || !result.data ? 'unknown' : 'unread' };
+        }
+        catch {
+            return { state: 'unknown' };
+        }
+    }
     updateSettings(next) {
         const needsRestart = next.enabled !== this.settings.enabled ||
             next.appId !== this.settings.appId ||
@@ -165,6 +324,19 @@ export class FeishuBotBridge extends BaseBotAdapter {
             const event = feishuMessageToEvent(message, receivedAt);
             if (!event || this.channel !== channel)
                 return;
+            const assistant = this.settings.messageHandling === 'assistant';
+            if (assistant &&
+                (event.isGroup ||
+                    this.settings.allowedUserIds?.length !== 1 ||
+                    this.settings.allowedUserIds[0] !== event.userId))
+                return;
+            if (this.settings.allowedUserIds?.length &&
+                !this.settings.allowedUserIds.includes(event.userId))
+                return;
+            // DM sends use open_id; task-mode replies use chat_id.
+            this.lastMessage.set(assistant ? event.userId : event.chatId, event.sourceMessageId);
+            if (this.lastMessage.size > 500)
+                this.lastMessage.delete(this.lastMessage.keys().next().value);
             if (!this.emitIncomingMessage(event))
                 return;
             this.readiness = 'operational';

package/node_modules/@maka/runtime/dist/bots/wechat-bridge.js

@@ -17,7 +17,9 @@
  * under the License.
  */
 import { generalizedErrorMessage } from '@maka/core/redaction';
-import { randomBytes, randomUUID } from 'node:crypto';
+import { createHash, randomBytes, randomUUID } from 'node:crypto';
+import { mkdir, readFile, rename, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
 import { createRequire } from 'node:module';
 import { BaseBotAdapter, botDiagnosticMessage, botReadinessFromSettings } from './base-adapter.js';
 import { proxiedFetch } from './proxied-fetch.js';
@@ -73,9 +75,15 @@ export function normalizeWechatSendTarget(value) {
     return target.length > 0 ? target : null;
 }
 export class WechatBridge extends BaseBotAdapter {
+    contextDirectory;
     abortController = null;
-    constructor(settings) {
+    contextTokens = new Map();
+    typingTickets = new Map();
+    typingQueue = Promise.resolve();
+    lifecycleStart = Promise.resolve();
+    constructor(settings, contextDirectory) {
         super('wechat', settings);
+        this.contextDirectory = contextDirectory;
     }
     async start() {
         if (this.running)
@@ -116,6 +124,8 @@ export class WechatBridge extends BaseBotAdapter {
             this.emitStatusChange();
         };
         if (isWechatIlinkChannel(this.settings)) {
+            this.lifecycleStart = this.notifyLifecycle('start');
+            await this.restoreContexts();
             void this.streamIlinkMessages('').catch(fail);
         }
         else {
@@ -123,13 +133,76 @@ export class WechatBridge extends BaseBotAdapter {
         }
     }
     async stop() {
+        const wasRunning = this.running;
         this.running = false;
         this.abortController?.abort();
         this.abortController = null;
+        await this.typingQueue;
+        await Promise.all([...this.typingTickets.keys()].map((id) => this.cancelTypingIndicator(id)));
+        this.contextTokens.clear();
+        this.typingTickets.clear();
+        if (wasRunning && isWechatIlinkChannel(this.settings)) {
+            await this.lifecycleStart;
+            await this.notifyLifecycle('stop');
+        }
         this.reason = 'stopped';
         this.readiness = botReadinessFromSettings(this.settings);
         this.emitStatusChange();
     }
+    async notifyLifecycle(kind) {
+        try {
+            const response = await wechatIlinkPost(this.settings.webhookUrl, `/ilink/bot/msg/notify${kind}`, { base_info: WECHAT_ILINK_BASE_INFO }, this.settings.token, undefined, 3000);
+            assertIlinkSuccess(response);
+        }
+        catch {
+            // Presence is advisory: it must not disable an otherwise working channel.
+            console.warn(`[bots:wechat] notify${kind} failed`);
+        }
+    }
+    sendTypingIndicator(chatId) {
+        return this.setTyping(chatId, true);
+    }
+    cancelTypingIndicator(chatId) {
+        return this.setTyping(chatId, false);
+    }
+    setTyping(chatId, active) {
+        // Serialize start/cancel so a slow start request cannot land after cancellation.
+        const pending = this.typingQueue.then(async () => {
+            if (!isWechatIlinkChannel(this.settings) || (active && !this.running))
+                return false;
+            if (this.settings.allowedUserIds?.length && !this.settings.allowedUserIds.includes(chatId))
+                return false;
+            try {
+                const context = this.contextTokens.get(chatId);
+                let cached = this.typingTickets.get(chatId);
+                if (active && (!cached || cached.context !== context || Date.now() - cached.at > 300000)) {
+                    const response = await wechatIlinkPost(this.settings.webhookUrl, '/ilink/bot/getconfig', { ilink_user_id: chatId, context_token: context, base_info: WECHAT_ILINK_BASE_INFO }, this.settings.token, undefined, 3000);
+                    if (response.ret !== 0 ||
+                        typeof response.typing_ticket !== 'string' ||
+                        !response.typing_ticket)
+                        return false;
+                    cached = { context, ticket: response.typing_ticket, at: Date.now() };
+                    this.typingTickets.set(chatId, cached);
+                }
+                if (!cached || (active && !this.running))
+                    return false;
+                const response = await wechatIlinkPost(this.settings.webhookUrl, '/ilink/bot/sendtyping', {
+                    ilink_user_id: chatId,
+                    typing_ticket: cached.ticket,
+                    status: active ? 1 : 2,
+                    base_info: WECHAT_ILINK_BASE_INFO,
+                }, this.settings.token, undefined, 3000);
+                assertIlinkSuccess(response);
+                return true;
+            }
+            catch {
+                this.typingTickets.delete(chatId);
+                return false;
+            }
+        });
+        this.typingQueue = pending.catch(() => false);
+        return pending;
+    }
     async sendMessage(chatId, text, _options) {
         if (!this.running)
             return null;
@@ -257,9 +330,21 @@ export class WechatBridge extends BaseBotAdapter {
                     cursor = nextCursor;
                 const messages = Array.isArray(response.msgs) ? response.msgs : [];
                 for (const message of messages) {
+                    if (!this.running)
+                        break;
                     const event = mapWechatIlinkMessage(message);
                     if (!event)
                         continue;
+                    if (this.settings.allowedUserIds?.length &&
+                        !this.settings.allowedUserIds.includes(event.userId))
+                        continue;
+                    const contextToken = stringField(message.context_token);
+                    if (contextToken) {
+                        this.contextTokens.set(event.userId, contextToken);
+                        while (this.contextTokens.size > 1000)
+                            this.contextTokens.delete(this.contextTokens.keys().next().value);
+                        await this.saveContexts();
+                    }
                     if (!this.emitIncomingMessage(event))
                         continue;
                     this.readiness = 'operational';
@@ -284,29 +369,77 @@ export class WechatBridge extends BaseBotAdapter {
             }
         }
     }
+    contextPath() {
+        if (!this.contextDirectory)
+            return undefined;
+        const key = createHash('sha256')
+            .update(JSON.stringify([this.settings.webhookUrl, this.settings.botUserId, this.settings.token]))
+            .digest('hex');
+        return join(this.contextDirectory, `${key}.json`);
+    }
+    async restoreContexts() {
+        const path = this.contextPath();
+        if (!path)
+            return;
+        try {
+            const value = JSON.parse(await readFile(path, 'utf8'));
+            if (!Array.isArray(value))
+                throw Error('Invalid context cache');
+            this.contextTokens = new Map(value
+                .filter((v) => Array.isArray(v) && v.length === 2 && v.every((s) => typeof s === 'string'))
+                .slice(-1000));
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                console.warn('[bots:wechat] Could not restore reply context; waiting for a new message');
+        }
+    }
+    async saveContexts() {
+        const path = this.contextPath();
+        if (!path)
+            return;
+        try {
+            await mkdir(this.contextDirectory, { recursive: true, mode: 0o700 });
+            const temporary = `${path}.${randomUUID()}.tmp`;
+            await writeFile(temporary, JSON.stringify([...this.contextTokens]), { mode: 0o600 });
+            await rename(temporary, path);
+        }
+        catch {
+            console.warn('[bots:wechat] Could not persist reply context; using in-memory context');
+        }
+    }
     async sendIlinkMessage(chatId, text) {
         const baseUrl = normalizeWechatIlinkBaseUrl(this.settings.webhookUrl);
         const token = this.settings.token.trim();
         if (!baseUrl || !token)
             return null;
         const clientId = randomUUID();
-        await wechatIlinkPost(baseUrl, '/ilink/bot/sendmessage', {
+        const response = await wechatIlinkPost(baseUrl, '/ilink/bot/sendmessage', {
             msg: {
                 to_user_id: chatId,
                 from_user_id: '',
                 client_id: clientId,
                 message_type: 2,
                 message_state: 2,
-                context_token: '',
+                context_token: this.contextTokens.get(chatId),
                 item_list: [{ type: 1, text_item: { text: stripMarkdownForWechat(text) } }],
             },
             base_info: WECHAT_ILINK_BASE_INFO,
         }, token);
+        if ((typeof response.ret === 'number' && response.ret !== 0) ||
+            (typeof response.errcode === 'number' && response.errcode !== 0)) {
+            throw new Error(`WeChat send failed: ret=${response.ret}, errcode=${response.errcode}`);
+        }
         this.readiness = 'operational';
         this.reason = undefined;
         this.lastEventAt = Date.now();
         this.emitStatusChange();
-        return clientId;
+        // Submission acknowledgement only; this is not a delivery/read receipt.
+        return typeof response.message_id === 'string' && response.message_id
+            ? response.message_id
+            : Number.isSafeInteger(response.message_id)
+                ? String(response.message_id)
+                : clientId;
     }
 }
 export async function getWechatBridgeQrCode(channel) {
@@ -372,6 +505,8 @@ export function mapWechatIlinkMessage(raw) {
     if (!raw || typeof raw !== 'object')
         return null;
     const message = raw;
+    if (message.message_type === 2 || message.group_id)
+        return null;
     const itemList = Array.isArray(message.item_list) ? message.item_list : [];
     const textParts = [];
     let hasMedia = false;
@@ -403,7 +538,12 @@ export function mapWechatIlinkMessage(raw) {
     if (!userId)
         return null;
     const messageId = firstStringField(message, ['msg_id', 'message_id', 'client_id', 'id']) ?? randomUUID();
-    const timestamp = firstNumberField(message, ['create_time', 'timestamp', 'createdAt']);
+    const timestamp = firstNumberField(message, [
+        'create_time_ms',
+        'create_time',
+        'timestamp',
+        'createdAt',
+    ]);
     return {
         platform: 'wechat',
         userId,
@@ -561,7 +701,7 @@ export async function testWechatIlinkCredentials(channel) {
 function isWechatIlinkChannel(channel) {
     return Boolean(normalizeWechatIlinkBaseUrl(channel.webhookUrl));
 }
-async function wechatIlinkPost(baseUrl, path, body, token, signal) {
+async function wechatIlinkPost(baseUrl, path, body, token, signal, timeoutMs = WECHAT_ILINK_TIMEOUT_MS) {
     const response = await proxiedFetch(`${baseUrl}${path}`, {
         method: 'POST',
         headers: {
@@ -573,12 +713,26 @@ async function wechatIlinkPost(baseUrl, path, body, token, signal) {
         },
         body: JSON.stringify(body),
         signal,
-        timeoutMs: path.includes('getupdates') ? 0 : WECHAT_ILINK_TIMEOUT_MS,
+        timeoutMs: path.includes('getupdates') ? 0 : timeoutMs,
     });
     const text = await response.text();
     if (!response.ok)
         throw new Error(`HTTP ${response.status}: ${text}`);
-    return JSON.parse(text);
+    // iLink IDs are uint64: preserve their original digits before Number rounding.
+    // sendTyping may acknowledge with an empty body.
+    if (!text.trim() && path.endsWith('/sendtyping'))
+        return {};
+    return JSON.parse(text, (key, value, context) => key === 'message_id' &&
+        typeof value === 'number' &&
+        context?.source &&
+        /^\d+$/.test(context.source)
+        ? context.source
+        : value);
+}
+function assertIlinkSuccess(response) {
+    if ((typeof response.ret === 'number' && response.ret !== 0) ||
+        (typeof response.errcode === 'number' && response.errcode !== 0))
+        throw Error('WeChat request rejected');
 }
 function randomWechatUinHeader() {
     return Buffer.from(String(randomBytes(4).readUInt32LE(0)), 'utf8').toString('base64');

package/node_modules/@maka/runtime/dist/context-budget-policy.js

@@ -20,20 +20,27 @@ import { declaredContextWindow, resolveModelLimits, modelLimitsConflict, } from
 /**
  * The shipped context-budget policy. It carries no history budget and no
  * reserve: whether a request fits is the provider's answer, and the only
- * proactive threshold is the context window the user declared for the model
+ * default proactive threshold is the one the user declared for the model
  * (see `resolveDeclaredContextWindow`), read by the compaction seam itself.
+ * A Host may opt a long-lived surface into a fallback target.
  * What remains here are content policies — how one oversized Tool Result
  * enters the request — and the compaction switches (#4559).
  */
 export function buildDefaultContextBudgetPolicy(options = {}) {
     const surfaceName = (options.name ?? 'default-history-budget').replace(/-default-history-budget$/, '');
+    const fallback = options.fallbackCompactionThresholdTokens;
     return {
         name: options.name ?? 'default-history-budget',
         toolResultPrune: { enabled: true },
         historyCompact: {
             enabled: true,
             highWaterName: `${surfaceName}-history-compact`,
-            midTurn: { enabled: true },
+            midTurn: {
+                enabled: true,
+                ...(typeof fallback === 'number' && Number.isFinite(fallback) && fallback > 0
+                    ? { fallbackThresholdTokens: fallback }
+                    : {}),
+            },
         },
     };
 }

package/node_modules/@maka/runtime/dist/event-wait-tool.js

@@ -0,0 +1,69 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+import { z } from 'zod';
+export const EVENT_WAIT_TOOL_NAME = 'WaitForEvent';
+const receipts = new WeakSet();
+/** Only the internal tool can produce a live yield capability. Persisted JSON is not authority. */
+export function isEventWaitYieldReceipt(value) {
+    return typeof value === 'object' && value !== null && receipts.has(value);
+}
+/** Host composition seam; exposed only with supported sources and valid Goal control. */
+export function buildEventWaitTool(register) {
+    return {
+        name: EVENT_WAIT_TOOL_NAME,
+        description: 'Wait for a background Bash task in this Session and end this Turn. Requires an active Goal and direct tools. Use resource {providerId: "shell_run", connectionId: null, resourceType: "background_task", resourceId: the canonical maka://runtime/background-tasks/... ref}, condition {typeId: "terminal", version: 1, parameters: {}} and an explicit timeoutMs. Host continues the existing Goal when the task becomes terminal or the wait expires. Terminal does not mean command success or Goal achievement: inspect the result with Read. Expiry or cancelling the wait does not stop the task.',
+        parameters: z
+            .object({
+            resource: z
+                .object({
+                providerId: z.string(),
+                connectionId: z.string().nullable(),
+                resourceType: z.string(),
+                resourceId: z.string(),
+            })
+                .strict(),
+            condition: z
+                .object({
+                typeId: z.string(),
+                version: z.number().int().positive(),
+                parameters: z.record(z.string(), z.unknown()),
+            })
+                .strict(),
+            reason: z.string().min(1).max(500),
+            timeoutMs: z
+                .number()
+                .int()
+                .positive()
+                .max(7 * 24 * 60 * 60_000),
+        })
+            .strict(),
+        executionSemantics: 'exclusive_step',
+        nesting: 'direct_only',
+        recoveryMode: 'never_auto_retry',
+        impl: async (input, context) => {
+            const result = await register(input, context);
+            const receipt = Object.freeze({
+                kind: 'event_wait_registered',
+                ...result,
+            });
+            receipts.add(receipt);
+            return receipt;
+        },
+    };
+}