@canonmsg/agent-sdk 3.4.4 → 5.0.0

package/dist/canon-agent.js

@@ -1077,13 +1077,13 @@ export class CanonAgent {
      * where the last-started agent's token wins in multi-agent processes.
      */
     createRuntimeStatePublisher() {
-        if (!this.agentId || !this.rtdbHandle)
+        if (!this.agentId)
             return null;
         return createRuntimeStatePublisher({
-            rtdb: this.rtdbHandle,
             agentId: this.agentId,
             clientType: this.options.clientType ?? 'generic',
             hostMode: this.options.runtimeControlSurface === 'host',
+            ...(this.rtdbHandle ? { rtdb: this.rtdbHandle } : {}),
         });
     }
     requireRuntimeStatePublisher() {
@@ -1393,11 +1393,7 @@ export class CanonAgent {
             const deleteMessage = (messageId) => this.apiClient.deleteMessage(conversationId, messageId);
             const markAsRead = () => this.apiClient.markAsRead(conversationId);
             const leave = () => this.apiClient.leaveConversation(conversationId);
-            // Handler contract stays Promise<void>; the client's toggle result
-            // (added/removed + reactions) is a bridge-era addition it doesn't use.
-            const react = async (messageId, emoji) => {
-                await this.apiClient.react(conversationId, messageId, emoji);
-            };
+            const react = (messageId, emoji) => this.apiClient.react(conversationId, messageId, emoji);
             const addMember = (userId) => this.apiClient.addMember(conversationId, userId);
             const removeMember = (userId) => this.apiClient.removeMember(conversationId, userId);
             const sendContextualMessage = (target, text, options) => this.apiClient.sendContextualMessage({
@@ -1959,7 +1955,7 @@ export class CanonAgent {
                         await turnOutput.flush();
                     },
                     clear: async () => {
-                        await turnOutput.clear().catch(() => { });
+                        await turnOutput.clear();
                     },
                     setTool: async (text) => {
                         await writeTurn('tool');

package/dist/realtime.d.ts

@@ -4,22 +4,15 @@ 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)
+ * - Connection/status callbacks
  */
 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;
@@ -34,24 +27,9 @@ export declare class RealtimeManager {
     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: {

package/dist/realtime.js

@@ -1,14 +1,6 @@
 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;
@@ -19,22 +11,15 @@ function messageCreatedAtMs(createdAt) {
  * 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)
+ * - Connection/status callbacks
  */
 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;
@@ -51,15 +36,14 @@ export class RealtimeManager {
     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.
+                    // 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;
                     }
@@ -122,20 +106,13 @@ export class RealtimeManager {
                     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();
+                    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);
@@ -143,22 +120,13 @@ export class RealtimeManager {
             },
         });
     }
-    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);
-        }
+        void createdAtMs;
         this.pruneRecentInboundMessageIds(now);
     }
     pruneRecentInboundMessageIds(now = Date.now()) {
@@ -175,75 +143,6 @@ export class RealtimeManager {
             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}`;

package/package.json

@@ -1,18 +1,18 @@
 {
   "name": "@canonmsg/agent-sdk",
-  "version": "3.4.4",
+  "version": "5.0.0",
   "description": "Canon Agent SDK — build AI agents that participate in Canon conversations",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "exports": {
     ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.js"
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
     },
     "./media": {
-      "types": "./dist/media.d.ts",
-      "import": "./dist/media.js"
+      "import": "./dist/media.js",
+      "types": "./dist/media.d.ts"
     }
   },
   "files": [
@@ -28,7 +28,7 @@
     "node": ">=18.0.0"
   },
   "dependencies": {
-    "@canonmsg/core": "^3.2.0"
+    "@canonmsg/core": "^4.0.0"
   },
   "publishConfig": {
     "access": "public"