@canonmsg/agent-sdk 3.4.3 → 4.0.0

package/dist/debouncer.d.ts

@@ -1,15 +0,0 @@
-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

@@ -1,98 +0,0 @@
-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/policy-history.d.ts

@@ -1,10 +0,0 @@
-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

@@ -1,11 +0,0 @@
-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

@@ -1,77 +0,0 @@
-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
- * - REST catch-up when the SSE replay window expires (replay.expired)
- */
-export declare class RealtimeManager {
-    private debouncer;
-    private agentId;
-    private apiClient;
-    private stream;
-    private running;
-    /** Recent inbound message IDs (`conversationId:messageId`) for cross-flush dedupe. */
-    private readonly recentInboundMessageIds;
-    /** Latest handled inbound message timestamp per conversation. */
-    private readonly lastInboundMessageAtByConversation;
-    /** Lower bound for catch-up in conversations with no in-memory cursor. */
-    private readonly replaySyncStartedAt;
-    private replayCatchupInFlight;
-    private hasConnectedOnce;
-    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 queueReplayCatchup;
-    private hasSeenInboundMessage;
-    private recordSeenInboundMessage;
-    private pruneRecentInboundMessageIds;
-    /**
-     * REST catch-up after `replay.expired`: the stream service evicted our
-     * cursor, so messages in the gap were silently dropped. Fetch the newest
-     * page per conversation and feed unseen inbound messages through the normal
-     * debouncer path (same entry point as SSE delivery, same id dedupe).
-     *
-     * Lower bound per conversation: the in-memory last-seen inbound timestamp,
-     * falling back to this manager's construction time for conversations with
-     * no prior inbound traffic — anything older predates this process and may
-     * already have been handled by a previous run. For the same reason the
-     * catch-up is NOT wired on initial connect: with no durable cursor, a fresh
-     * process would re-fire turns for messages an earlier run already answered.
-     */
-    private runReplayCatchup;
-    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

@@ -1,295 +0,0 @@
-import { CanonStream, } from '@canonmsg/core';
-import { shouldDispatchInboundMessage } from './turn-filter.js';
-const RECENT_INBOUND_TTL_MS = 30 * 60 * 1000;
-const MAX_RECENT_INBOUND_MESSAGE_IDS = 5000;
-/**
- * Newest-page bound for the replay-expiry REST catch-up. The SDK has no
- * durable per-conversation cursor (everything here is in-memory), so the
- * catch-up only inspects the newest page per conversation and relies on the
- * id-based dedupe below for anything that overlaps live SSE delivery.
- */
-const REPLAY_CATCHUP_PAGE_LIMIT = 50;
-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
- * - REST catch-up when the SSE replay window expires (replay.expired)
- */
-export class RealtimeManager {
-    debouncer;
-    agentId;
-    apiClient;
-    stream;
-    running = false;
-    /** Recent inbound message IDs (`conversationId:messageId`) for cross-flush dedupe. */
-    recentInboundMessageIds = new Map();
-    /** Latest handled inbound message timestamp per conversation. */
-    lastInboundMessageAtByConversation = new Map();
-    /** Lower bound for catch-up in conversations with no in-memory cursor. */
-    replaySyncStartedAt = Date.now();
-    replayCatchupInFlight = null;
-    hasConnectedOnce = false;
-    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.apiClient = apiClient ?? null;
-        this.stream = new CanonStream({
-            apiKey,
-            agentId,
-            streamUrl,
-            handler: {
-                onMessage: (payload) => {
-                    // Cross-flush id dedupe: replay overlap or a concurrent REST
-                    // catch-up 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: () => {
-                    // Reset backoff is handled internally by CanonStream
-                    const shouldCatchUp = this.hasConnectedOnce;
-                    this.hasConnectedOnce = true;
-                    this.onConnected?.();
-                    if (shouldCatchUp) {
-                        this.queueReplayCatchup();
-                    }
-                },
-                onDisconnected: () => {
-                    this.onDisconnected?.();
-                },
-                onReplayExpired: (payload) => {
-                    console.error(`[canon-sdk] SSE replay window expired${payload.lastAvailableId ? ` (oldest available event: ${payload.lastAvailableId})` : ''} — catching up over REST`);
-                    this.queueReplayCatchup();
-                },
-                onError: (err) => {
-                    this.logSseError(err);
-                },
-            },
-        });
-    }
-    queueReplayCatchup() {
-        this.replayCatchupInFlight ??= this.runReplayCatchup().finally(() => {
-            this.replayCatchupInFlight = null;
-        });
-    }
-    hasSeenInboundMessage(conversationId, messageId) {
-        return this.recentInboundMessageIds.has(`${conversationId}:${messageId}`);
-    }
-    recordSeenInboundMessage(conversationId, messageId, createdAtMs) {
-        const now = Date.now();
-        this.recentInboundMessageIds.set(`${conversationId}:${messageId}`, now);
-        const effectiveTimestamp = createdAtMs > 0 ? createdAtMs : now;
-        const previous = this.lastInboundMessageAtByConversation.get(conversationId) ?? 0;
-        if (effectiveTimestamp > previous) {
-            this.lastInboundMessageAtByConversation.set(conversationId, effectiveTimestamp);
-        }
-        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);
-        }
-    }
-    /**
-     * REST catch-up after `replay.expired`: the stream service evicted our
-     * cursor, so messages in the gap were silently dropped. Fetch the newest
-     * page per conversation and feed unseen inbound messages through the normal
-     * debouncer path (same entry point as SSE delivery, same id dedupe).
-     *
-     * Lower bound per conversation: the in-memory last-seen inbound timestamp,
-     * falling back to this manager's construction time for conversations with
-     * no prior inbound traffic — anything older predates this process and may
-     * already have been handled by a previous run. For the same reason the
-     * catch-up is NOT wired on initial connect: with no durable cursor, a fresh
-     * process would re-fire turns for messages an earlier run already answered.
-     */
-    async runReplayCatchup() {
-        const apiClient = this.apiClient;
-        if (!apiClient) {
-            console.error('[canon-sdk] Replay catch-up skipped — no API client available');
-            return;
-        }
-        try {
-            const conversations = await apiClient.getConversations();
-            let recovered = 0;
-            await Promise.all(conversations.map(async (conversation) => {
-                try {
-                    const page = await apiClient.getMessagesPage(conversation.id, REPLAY_CATCHUP_PAGE_LIMIT);
-                    const lowerBoundMs = this.lastInboundMessageAtByConversation.get(conversation.id)
-                        ?? this.replaySyncStartedAt;
-                    const candidates = [...(page.messages ?? [])]
-                        .filter((message) => !message.deleted)
-                        .sort((a, b) => messageCreatedAtMs(a.createdAt) - messageCreatedAtMs(b.createdAt));
-                    for (const message of candidates) {
-                        if (!this.running)
-                            return;
-                        if (message.senderId === this.agentId)
-                            continue;
-                        const createdAtMs = messageCreatedAtMs(message.createdAt);
-                        // Use a strict lower bound of `< lowerBoundMs` (not `<=`): a
-                        // gap-dropped message can share the same createdAt millisecond as
-                        // the last message seen over SSE (server timestamps collide under
-                        // bursts — exactly the scenario catch-up targets). The id-dedupe on
-                        // the next line suppresses the already-delivered boundary message,
-                        // so excluding by `<=` would only drop never-seen same-ms peers.
-                        if (!createdAtMs || createdAtMs < lowerBoundMs)
-                            continue;
-                        if (this.hasSeenInboundMessage(conversation.id, message.id))
-                            continue;
-                        this.recordSeenInboundMessage(conversation.id, message.id, createdAtMs);
-                        const dispatch = await shouldDispatchInboundMessage(conversation.id, this.agentId, message, {
-                            conversationType: conversation.type,
-                            behavior: page.behavior ?? null,
-                        });
-                        if (!dispatch)
-                            continue;
-                        this.debouncer.add(conversation.id, message, null);
-                        recovered += 1;
-                    }
-                }
-                catch (err) {
-                    console.error(`[canon-sdk] Replay catch-up failed for ${conversation.id}:`, err instanceof Error ? err.message : err);
-                }
-            }));
-            if (recovered > 0) {
-                console.error(`[canon-sdk] Replay catch-up recovered ${recovered} missed message(s)`);
-            }
-        }
-        catch (err) {
-            console.error('[canon-sdk] Replay catch-up failed:', err instanceof Error ? err.message : err);
-        }
-    }
-    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

@@ -1,29 +0,0 @@
-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

@@ -1,22 +0,0 @@
-/**
- * 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

@@ -1,9 +0,0 @@
-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

@@ -1,25 +0,0 @@
-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;
-}