@canonmsg/agent-sdk 4.0.0 → 5.0.0

package/dist/debouncer.d.ts

@@ -0,0 +1,15 @@
+import type { CanonMessage, CanonRuntimeProvenance } from '@canonmsg/core';
+export declare class Debouncer {
+    private debounceMs;
+    private pending;
+    private provenanceByMessageId;
+    private timers;
+    private orderedFlags;
+    private callback;
+    constructor(debounceMs: number);
+    setCallback(cb: (conversationId: string, messages: CanonMessage[], provenanceByMessageId: ReadonlyMap<string, CanonRuntimeProvenance>) => void): void;
+    add(conversationId: string, message: CanonMessage, provenance?: CanonRuntimeProvenance | null): void;
+    removeMessage(conversationId: string, messageId: string): boolean;
+    private flush;
+    destroy(): void;
+}

package/dist/debouncer.js

@@ -0,0 +1,98 @@
+export class Debouncer {
+    debounceMs;
+    pending = new Map();
+    provenanceByMessageId = new Map();
+    timers = new Map();
+    // Track whether each conversation's pending messages are already in sorted
+    // order so we can skip the sort on flush when possible (#10)
+    orderedFlags = new Map();
+    callback = null;
+    constructor(debounceMs) {
+        this.debounceMs = debounceMs;
+    }
+    setCallback(cb) {
+        this.callback = cb;
+    }
+    add(conversationId, message, provenance) {
+        const existing = this.pending.get(conversationId) || [];
+        if (provenance) {
+            this.provenanceByMessageId.set(message.id, provenance);
+        }
+        // Deduplicate by message ID
+        if (!existing.some((m) => m.id === message.id)) {
+            if (existing.length === 0) {
+                // First message for this conversation — trivially ordered
+                this.orderedFlags.set(conversationId, true);
+            }
+            else if (this.orderedFlags.get(conversationId) !== false) {
+                // Still potentially ordered — check if new message maintains sort order
+                const lastTime = new Date(existing[existing.length - 1].createdAt).getTime();
+                const newTime = new Date(message.createdAt).getTime();
+                if (newTime < lastTime) {
+                    this.orderedFlags.set(conversationId, false);
+                }
+            }
+            existing.push(message);
+            this.pending.set(conversationId, existing);
+        }
+        // Reset timer for this conversation
+        const existingTimer = this.timers.get(conversationId);
+        if (existingTimer)
+            clearTimeout(existingTimer);
+        this.timers.set(conversationId, setTimeout(() => {
+            this.flush(conversationId);
+        }, this.debounceMs));
+    }
+    removeMessage(conversationId, messageId) {
+        const existing = this.pending.get(conversationId);
+        if (!existing || existing.length === 0)
+            return false;
+        const next = existing.filter((message) => message.id !== messageId);
+        if (next.length === existing.length)
+            return false;
+        this.provenanceByMessageId.delete(messageId);
+        if (next.length === 0) {
+            this.pending.delete(conversationId);
+            this.orderedFlags.delete(conversationId);
+            const timer = this.timers.get(conversationId);
+            if (timer)
+                clearTimeout(timer);
+            this.timers.delete(conversationId);
+        }
+        else {
+            this.pending.set(conversationId, next);
+        }
+        return true;
+    }
+    flush(conversationId) {
+        const messages = this.pending.get(conversationId);
+        const isOrdered = this.orderedFlags.get(conversationId) ?? false;
+        this.pending.delete(conversationId);
+        this.timers.delete(conversationId);
+        this.orderedFlags.delete(conversationId);
+        if (messages && messages.length > 0 && this.callback) {
+            // Only sort if insertions arrived out of order (#10)
+            if (!isOrdered) {
+                messages.sort((a, b) => new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime());
+            }
+            const provenanceByMessageId = new Map();
+            for (const message of messages) {
+                const provenance = this.provenanceByMessageId.get(message.id);
+                if (provenance) {
+                    provenanceByMessageId.set(message.id, provenance);
+                    this.provenanceByMessageId.delete(message.id);
+                }
+            }
+            this.callback(conversationId, messages, provenanceByMessageId);
+        }
+    }
+    destroy() {
+        for (const timer of this.timers.values()) {
+            clearTimeout(timer);
+        }
+        this.timers.clear();
+        this.pending.clear();
+        this.provenanceByMessageId.clear();
+        this.orderedFlags.clear();
+    }
+}

package/dist/index.d.ts

@@ -1,4 +1,10 @@
+export { CanonAgent } from './canon-agent.js';
+export type { AgentContactsAPI, AgentConversationsAPI, AgentUsersAPI } from './canon-agent.js';
+export { ApprovalManager, buildApprovalOutcome, buildApprovalReply, buildApprovalRequest, CanonApiError, DEFAULT_APPROVAL_CONFIG, generateApprovalId, HOST_ADMISSION_ACTION_CAPABILITIES, HOST_ADMISSION_ACTIONS_DISABLED, parseApprovalReplyMetadata, parseApprovalRequestMetadata, parseSessionRule, redactSecrets, } from '@canonmsg/core';
+export type { ApprovalConfig, ApprovalNativeRequestMetadata, ApprovalOutcomeMetadata, ApprovalReplyMetadata, ApprovalRequestCategory, ApprovalRequestDetail, ApprovalRequestMetadata, ApprovalResult, ApprovalRisk, CanonContact, CanonRuntimeActivityItem, CanonRuntimeActivityKind, CanonRuntimeActivityStatus, CanonRuntimeTurnModeActivation, CanonRuntimeTurnModeDescriptor, CanonRuntimeTurnModeScope, CanonRuntimeFact, CanonRuntimeFactGroup, CanonResolveAdmissionResult, ContactAddedPayload, ContactCardPayload, ContactRemovedPayload, ContactSource, HostAdmissionActionCapabilities, ResolveAdmissionTargetInput, ResolvedAdmissionState, ResolvedAdmissionTargetSummary, ResolvedTargetAdmissionPayload, RuntimeInputAnswers, RuntimeInputChoice, RuntimeInputKind, RuntimeInputNativeMetadata, RuntimeInputQuestion, SessionRule, } from '@canonmsg/core';
 export { SessionManager } from './session-manager.js';
-export type { EnqueueOptions, Session, SessionConfig } from './session-manager.js';
 export { DEFAULT_MEDIA_CACHE_DIR, getCodexImagePath, getMessageAttachments, inferUploadMimeType, isAnthropicImageAttachment, materializeAttachment, materializeMessageMedia, materializeReplyContextMedia, resolveAttachmentMimeType, sendMediaFileMessage, toAnthropicImageBlock, uploadMediaFile, } from './media.js';
 export type { AnthropicImageBlock, AnthropicImageMimeType, MaterializeMediaOptions, MaterializedCanonAttachment, MaterializedCanonReplyContext, ReplyWithFileOptions, UploadMediaFileOptions, } from './media.js';
+export type { SessionConfig, Session } from './session-manager.js';
+export type { AgentContext, CanonGroupContext, CanonKnownRecentParticipant, CanonMembershipChange, CanonContactRequest, CanonMessage, CanonConversation, CanonReplyContext, CanonSelfContext, CanonTurnContextV2, CanonRuntimeDescriptor, MessageUpdatedPayload, SendContextualMessageOptions, SendContextualMessageResult, SendContextualSelfContextInput, SendMessageOptions, CreateConversationOptions, CreateConversationResult, DirectSessionSelection, } from '@canonmsg/core';
+export type { CanonAgentOptions, ContactAddedHandler, ContactRemovedHandler, ContactRequestHandler, MessageHandler, MessageHandlerContext, MessageUpdatedHandler, ProgressMessageOptions, ProgressMessageResult, ReachOutOptions, ReachOutResult, RuntimeApprovalRequest, RuntimeInputRequest, RuntimeInputResult, RuntimeControlSurface, RuntimePrimitiveContext, RuntimePrimitiveHandler, RuntimePrimitiveHandlers, SessionInfo, SessionOptions, DeliveryMode, } from './types.js';

package/dist/index.js

@@ -1,8 +1,4 @@
-// @canonmsg/agent-sdk — media helpers + in-process session queue.
-//
-// The pre-bridge CanonAgent runtime (SSE loop, RTDB control polling, HITL
-// custody) was retired in the housecleaning campaign (W2-A1). Standalone
-// agents speak Canon through @canonmsg/framework + the canon-bridge daemon;
-// the published 3.x line keeps the old runtime for anyone pinned to it.
+export { CanonAgent } from './canon-agent.js';
+export { ApprovalManager, buildApprovalOutcome, buildApprovalReply, buildApprovalRequest, CanonApiError, DEFAULT_APPROVAL_CONFIG, generateApprovalId, HOST_ADMISSION_ACTION_CAPABILITIES, HOST_ADMISSION_ACTIONS_DISABLED, parseApprovalReplyMetadata, parseApprovalRequestMetadata, parseSessionRule, redactSecrets, } from '@canonmsg/core';
 export { SessionManager } from './session-manager.js';
 export { DEFAULT_MEDIA_CACHE_DIR, getCodexImagePath, getMessageAttachments, inferUploadMimeType, isAnthropicImageAttachment, materializeAttachment, materializeMessageMedia, materializeReplyContextMedia, resolveAttachmentMimeType, sendMediaFileMessage, toAnthropicImageBlock, uploadMediaFile, } from './media.js';

package/dist/policy-history.d.ts

@@ -0,0 +1,10 @@
+import { type CanonMessage, type ParticipationHistorySnapshot } from '@canonmsg/core';
+export type { ParticipationHistorySnapshot } from '@canonmsg/core';
+/**
+ * Builds message-specific participation history snapshots for backlog delivery.
+ *
+ * `messages` must be ordered newest-first, matching Canon's `getMessages()`
+ * API. Each snapshot is computed from older history only, never from the
+ * target message itself or newer messages that had not occurred yet.
+ */
+export declare function buildParticipationHistorySnapshots(messages: CanonMessage[], agentId: string): Map<string, ParticipationHistorySnapshot>;

package/dist/policy-history.js

@@ -0,0 +1,11 @@
+import { buildParticipationHistorySnapshots as buildSharedParticipationHistorySnapshots, } from '@canonmsg/core';
+/**
+ * Builds message-specific participation history snapshots for backlog delivery.
+ *
+ * `messages` must be ordered newest-first, matching Canon's `getMessages()`
+ * API. Each snapshot is computed from older history only, never from the
+ * target message itself or newer messages that had not occurred yet.
+ */
+export function buildParticipationHistorySnapshots(messages, agentId) {
+    return buildSharedParticipationHistorySnapshots(messages, agentId);
+}

package/dist/realtime.d.ts

@@ -0,0 +1,55 @@
+import { type AgentContext, type CanonClient, type ContactAddedPayload, type ContactApprovedPayload, type ContactRemovedPayload, type ContactRequestPayload, type ConversationUpdatedPayload, type MessageUpdatedPayload } from '@canonmsg/core';
+import { Debouncer } from './debouncer.js';
+/**
+ * Wraps @canonmsg/core's CanonStream with SDK-specific features:
+ * - Debouncer integration (message batching)
+ * - Agent context callback
+ * - Connection/status callbacks
+ */
+export declare class RealtimeManager {
+    private debouncer;
+    private agentId;
+    private stream;
+    private running;
+    /** Recent inbound message IDs (`conversationId:messageId`) for cross-flush dedupe. */
+    private readonly recentInboundMessageIds;
+    private lastSseErrorKey;
+    private lastSseErrorAt;
+    private suppressedSseErrorCount;
+    private onAgentContext;
+    private onContactRequest;
+    private onContactApproved;
+    private onContactAdded;
+    private onContactRemoved;
+    private onConversationUpdated;
+    private onMessageUpdated;
+    private onMessageDeleted;
+    private onConnected;
+    private onDisconnected;
+    constructor(apiKey: string, debouncer: Debouncer, agentId: string, streamUrl?: string, apiClient?: CanonClient);
+    private hasSeenInboundMessage;
+    private recordSeenInboundMessage;
+    private pruneRecentInboundMessageIds;
+    private logSseError;
+    setOnAgentContext(cb: (ctx: AgentContext) => void): void;
+    setContactRequestHandlers(handlers: {
+        onContactRequest?: (payload: ContactRequestPayload) => void;
+        onContactApproved?: (payload: ContactApprovedPayload) => void;
+    }): void;
+    setContactGraphHandlers(handlers: {
+        onContactAdded?: (payload: ContactAddedPayload) => void;
+        onContactRemoved?: (payload: ContactRemovedPayload) => void;
+    }): void;
+    setConversationUpdatedHandler(cb: (payload: ConversationUpdatedPayload) => void): void;
+    setMessageUpdatedHandler(cb: (payload: MessageUpdatedPayload) => void): void;
+    setMessageDeletedHandler(cb: (payload: {
+        conversationId: string;
+        messageId: string;
+    }) => void): void;
+    setConnectionHandlers(handlers: {
+        onConnected?: () => void;
+        onDisconnected?: () => void;
+    }): void;
+    start(): Promise<void>;
+    stop(): void;
+}

package/dist/realtime.js

@@ -0,0 +1,194 @@
+import { CanonStream, } from '@canonmsg/core';
+const RECENT_INBOUND_TTL_MS = 30 * 60 * 1000;
+const MAX_RECENT_INBOUND_MESSAGE_IDS = 5000;
+function messageCreatedAtMs(createdAt) {
+    if (!createdAt)
+        return 0;
+    const parsed = new Date(createdAt).getTime();
+    return Number.isFinite(parsed) ? parsed : 0;
+}
+/**
+ * Wraps @canonmsg/core's CanonStream with SDK-specific features:
+ * - Debouncer integration (message batching)
+ * - Agent context callback
+ * - Connection/status callbacks
+ */
+export class RealtimeManager {
+    debouncer;
+    agentId;
+    stream;
+    running = false;
+    /** Recent inbound message IDs (`conversationId:messageId`) for cross-flush dedupe. */
+    recentInboundMessageIds = new Map();
+    lastSseErrorKey = null;
+    lastSseErrorAt = 0;
+    suppressedSseErrorCount = 0;
+    onAgentContext = null;
+    onContactRequest = null;
+    onContactApproved = null;
+    onContactAdded = null;
+    onContactRemoved = null;
+    onConversationUpdated = null;
+    onMessageUpdated = null;
+    onMessageDeleted = null;
+    onConnected = null;
+    onDisconnected = null;
+    constructor(apiKey, debouncer, agentId, streamUrl, apiClient) {
+        this.debouncer = debouncer;
+        this.agentId = agentId;
+        this.stream = new CanonStream({
+            apiKey,
+            agentId,
+            streamUrl,
+            handler: {
+                onMessage: (payload) => {
+                    // Cross-flush id dedupe: SSE replay overlap must never double-fire
+                    // a turn for the same message.
+                    if (this.hasSeenInboundMessage(payload.conversationId, payload.message.id)) {
+                        return;
+                    }
+                    this.recordSeenInboundMessage(payload.conversationId, payload.message.id, messageCreatedAtMs(payload.message.createdAt));
+                    if (payload.turnDispatch && payload.turnDispatch.kind !== 'run_turn') {
+                        console.error(`[canon-sdk] Ignoring server-dispatched observe-only message in ${payload.conversationId}: ${payload.turnDispatch.reason}`);
+                        return;
+                    }
+                    const m = payload.message;
+                    const message = {
+                        id: m.id,
+                        senderId: m.senderId,
+                        ...(m.senderName ? { senderName: m.senderName } : {}),
+                        senderType: m.senderType ?? 'human',
+                        isOwner: m.isOwner ?? false,
+                        contentType: m.contentType ?? 'text',
+                        text: m.text ?? null,
+                        attachments: m.attachments ?? [],
+                        mentions: m.mentions ?? [],
+                        ...(m.reactions ? { reactions: m.reactions } : {}),
+                        replyTo: m.replyTo ?? null,
+                        replyToPosition: m.replyToPosition ?? null,
+                        ...(m.forwarded === true || m.forwardedFrom
+                            ? { forwarded: true }
+                            : {}),
+                        ...(m.forwardedFrom
+                            ? { forwardedFrom: m.forwardedFrom }
+                            : {}),
+                        status: 'sent',
+                        deleted: false,
+                        createdAt: m.createdAt ?? new Date().toISOString(),
+                        ...(m.contactCard ? { contactCard: m.contactCard } : {}),
+                        ...(m.metadata ? { metadata: m.metadata } : {}),
+                    };
+                    this.debouncer.add(payload.conversationId, message, payload.provenance ?? null);
+                },
+                onMessageDeleted: (payload) => {
+                    this.debouncer.removeMessage(payload.conversationId, payload.messageId);
+                    this.onMessageDeleted?.(payload);
+                },
+                onMessageUpdated: (payload) => {
+                    this.onMessageUpdated?.(payload);
+                },
+                onAgentContext: (ctx) => {
+                    this.onAgentContext?.(ctx);
+                },
+                onContactRequest: (payload) => {
+                    this.onContactRequest?.(payload);
+                },
+                onContactApproved: (payload) => {
+                    this.onContactApproved?.(payload);
+                },
+                onContactAdded: (payload) => {
+                    this.onContactAdded?.(payload);
+                },
+                onContactRemoved: (payload) => {
+                    this.onContactRemoved?.(payload);
+                },
+                onConversationUpdated: (payload) => {
+                    this.onConversationUpdated?.(payload);
+                },
+                onConnected: () => {
+                    this.onConnected?.();
+                },
+                onDisconnected: () => {
+                    this.onDisconnected?.();
+                },
+                onReplayExpired: (payload) => {
+                    console.error(`[canon-sdk] SSE replay window expired${payload.lastAvailableId ? ` (oldest available event: ${payload.lastAvailableId})` : ''}; missed history is available via explicit REST fetch`);
+                },
+                onError: (err) => {
+                    this.logSseError(err);
+                },
+            },
+        });
+    }
+    hasSeenInboundMessage(conversationId, messageId) {
+        return this.recentInboundMessageIds.has(`${conversationId}:${messageId}`);
+    }
+    recordSeenInboundMessage(conversationId, messageId, createdAtMs) {
+        const now = Date.now();
+        this.recentInboundMessageIds.set(`${conversationId}:${messageId}`, now);
+        void createdAtMs;
+        this.pruneRecentInboundMessageIds(now);
+    }
+    pruneRecentInboundMessageIds(now = Date.now()) {
+        const cutoff = now - RECENT_INBOUND_TTL_MS;
+        for (const [key, seenAt] of this.recentInboundMessageIds) {
+            if (seenAt < cutoff) {
+                this.recentInboundMessageIds.delete(key);
+            }
+        }
+        while (this.recentInboundMessageIds.size > MAX_RECENT_INBOUND_MESSAGE_IDS) {
+            const oldestKey = this.recentInboundMessageIds.keys().next().value;
+            if (!oldestKey)
+                break;
+            this.recentInboundMessageIds.delete(oldestKey);
+        }
+    }
+    logSseError(err) {
+        const code = err.code;
+        const key = `${typeof code === 'string' ? code : 'generic'}:${err.message}`;
+        const now = Date.now();
+        if (this.lastSseErrorKey === key && now - this.lastSseErrorAt < 60_000) {
+            this.suppressedSseErrorCount += 1;
+            return;
+        }
+        if (this.suppressedSseErrorCount > 0) {
+            console.error(`[canon-sdk] SSE error repeated ${this.suppressedSseErrorCount} more time${this.suppressedSseErrorCount === 1 ? '' : 's'}`);
+            this.suppressedSseErrorCount = 0;
+        }
+        this.lastSseErrorKey = key;
+        this.lastSseErrorAt = now;
+        console.error('[canon-sdk] SSE error:', err.message);
+    }
+    setOnAgentContext(cb) {
+        this.onAgentContext = cb;
+    }
+    setContactRequestHandlers(handlers) {
+        this.onContactRequest = handlers.onContactRequest ?? null;
+        this.onContactApproved = handlers.onContactApproved ?? null;
+    }
+    setContactGraphHandlers(handlers) {
+        this.onContactAdded = handlers.onContactAdded ?? null;
+        this.onContactRemoved = handlers.onContactRemoved ?? null;
+    }
+    setConversationUpdatedHandler(cb) {
+        this.onConversationUpdated = cb;
+    }
+    setMessageUpdatedHandler(cb) {
+        this.onMessageUpdated = cb;
+    }
+    setMessageDeletedHandler(cb) {
+        this.onMessageDeleted = cb;
+    }
+    setConnectionHandlers(handlers) {
+        this.onConnected = handlers.onConnected ?? null;
+        this.onDisconnected = handlers.onDisconnected ?? null;
+    }
+    async start() {
+        this.running = true;
+        await this.stream.start();
+    }
+    stop() {
+        this.running = false;
+        this.stream.stop();
+    }
+}

package/dist/runtime-card.d.ts

@@ -0,0 +1,29 @@
+import type { RuntimeCardNativeMetadata, RuntimeCardV1 } from '@canonmsg/core';
+import type { RuntimeCardRequest } from './types';
+/** Arguments passed to `CanonClient.createRuntimeCardRequest`. */
+export interface RuntimeCardCreateArgs {
+    conversationId: string;
+    card: RuntimeCardV1;
+    cardId: string;
+    expiresAt: number;
+    responseUserId?: string;
+    runtimeId?: string;
+    turnId?: string;
+    native?: RuntimeCardNativeMetadata;
+}
+/**
+ * Build the `createRuntimeCardRequest` payload shared by `sendCard` (display)
+ * and `requestCard` (interactive).
+ *
+ * `responseUserId` is OMITTED unless the developer supplied one, so the Canon
+ * backend infers a reachable responder (the owner when they are a conversation
+ * member, otherwise the sole other member). Pre-filling the owner here would
+ * break agent-to-user DMs where the owner is not a member of the conversation.
+ */
+export declare function buildRuntimeCardCreateArgs(input: {
+    request: RuntimeCardRequest;
+    conversationId: string;
+    cardId: string;
+    fallbackTurnId?: string;
+    expiresAtMs: number;
+}): RuntimeCardCreateArgs;

package/dist/runtime-card.js

@@ -0,0 +1,22 @@
+/**
+ * Build the `createRuntimeCardRequest` payload shared by `sendCard` (display)
+ * and `requestCard` (interactive).
+ *
+ * `responseUserId` is OMITTED unless the developer supplied one, so the Canon
+ * backend infers a reachable responder (the owner when they are a conversation
+ * member, otherwise the sole other member). Pre-filling the owner here would
+ * break agent-to-user DMs where the owner is not a member of the conversation.
+ */
+export function buildRuntimeCardCreateArgs(input) {
+    const { request, conversationId, cardId, fallbackTurnId, expiresAtMs } = input;
+    return {
+        conversationId,
+        cardId,
+        card: { ...request.card, cardId },
+        expiresAt: expiresAtMs,
+        ...(request.responseUserId ? { responseUserId: request.responseUserId } : {}),
+        ...(request.runtimeId ? { runtimeId: request.runtimeId } : {}),
+        turnId: request.turnId ?? fallbackTurnId,
+        ...(request.native ? { native: request.native } : {}),
+    };
+}

package/dist/turn-filter.d.ts

@@ -0,0 +1,9 @@
+import { type ResolvedAgentBehaviorPolicy, type CanonMessage, type MessageCreatedPayload } from '@canonmsg/core';
+export declare function shouldDispatchInboundMessage(_conversationId: string, agentId: string, message: CanonMessage, options?: {
+    conversationType?: 'direct' | 'group' | 'unknown';
+    behavior?: ResolvedAgentBehaviorPolicy | null;
+    recentHumanCount?: number;
+    consecutiveAgentTurns?: number;
+    currentAgentStreakStartedByHuman?: boolean;
+    turnDispatch?: MessageCreatedPayload['turnDispatch'];
+}): Promise<boolean>;

package/dist/turn-filter.js

@@ -0,0 +1,25 @@
+import { evaluateParticipationPolicy, shouldTriggerAgentTurn, } from '@canonmsg/core';
+export async function shouldDispatchInboundMessage(_conversationId, agentId, message, options) {
+    if (message.senderId === agentId)
+        return false;
+    if (options?.turnDispatch) {
+        return options.turnDispatch.kind === 'run_turn';
+    }
+    const triggerDecision = shouldTriggerAgentTurn({
+        senderType: message.senderType,
+        metadata: message.metadata,
+    });
+    if (!triggerDecision.allow)
+        return false;
+    if (!options?.behavior)
+        return true;
+    return evaluateParticipationPolicy(options.behavior, {
+        conversationType: options.conversationType ?? 'unknown',
+        senderType: message.senderType,
+        isOwner: message.isOwner,
+        mentionedAgent: Array.isArray(message.mentions) && message.mentions.includes(agentId),
+        recentHumanCount: options.recentHumanCount,
+        consecutiveAgentTurns: options.consecutiveAgentTurns,
+        currentAgentStreakStartedByHuman: options.currentAgentStreakStartedByHuman,
+    }).allow;
+}