@canonmsg/agent-sdk 1.5.1 → 1.5.3

package/dist/canon-agent.d.ts

@@ -55,6 +55,7 @@ export declare class CanonAgent {
     private readonly activeTurns;
     private readonly conversationMemberIds;
     private readonly pendingMembershipChanges;
+    private sseConnectedLogged;
     constructor(options: CanonAgentOptions);
     private ensureApprovalManager;
     private filterApprovalReplyMessages;
@@ -116,6 +117,7 @@ export declare class CanonAgent {
     private hasRuntimeSignalSupport;
     private hasRuntimePrimitiveSupport;
     private hasRuntimeControlSupport;
+    private supportsInputInterrupt;
     private buildRuntimeDescriptor;
     private buildRuntimeCapabilities;
     private publishAgentRuntime;

package/dist/canon-agent.js

@@ -9,6 +9,7 @@ const RUNTIME_PRIMITIVE_DEDUPE_TTL_MS = 5 * 60 * 1000;
 const RUNTIME_PRIMITIVE_DEDUPE_MAX = 1_000;
 const SDK_RUNTIME_CAPABILITIES = {
     supportsInterrupt: false,
+    supportsInputInterrupt: false,
     supportsQueue: true,
     supportsInterleave: false,
     supportsRequiresAction: true,
@@ -218,6 +219,7 @@ export class CanonAgent {
     activeTurns = new Map();
     conversationMemberIds = new Map();
     pendingMembershipChanges = new Map();
+    sseConnectedLogged = false;
     constructor(options) {
         this.options = {
             baseUrl: 'https://api-6m6mlelskq-uc.a.run.app',
@@ -528,13 +530,21 @@ export class CanonAgent {
         rtm.setConversationUpdatedHandler((payload) => {
             this.handleConversationUpdated(payload);
         });
+        rtm.setMessageDeletedHandler((payload) => {
+            this.sessionManager?.dropQueuedMessage(payload.conversationId, payload.messageId);
+        });
         rtm.setConnectionHandlers({
-            onConnected: () => this.startRuntimeHeartbeat(),
+            onConnected: () => {
+                this.startRuntimeHeartbeat();
+                if (!this.sseConnectedLogged) {
+                    this.sseConnectedLogged = true;
+                    console.log('[canon-sdk] SSE stream connected');
+                }
+            },
             onDisconnected: () => this.stopRuntimeHeartbeat(),
         });
         this.realtimeManager = rtm;
         await rtm.start();
-        console.log('[canon-sdk] SSE stream started');
     }
     async createConversation(options) {
         return this.apiClient.createConversation(options);
@@ -633,6 +643,9 @@ export class CanonAgent {
     hasRuntimeControlSupport() {
         return this.hasRuntimeSignalSupport() || this.hasRuntimePrimitiveSupport();
     }
+    supportsInputInterrupt() {
+        return this.hasInterruptSupport() && this.options.runtimeDescriptor?.supportsInputInterrupt !== false;
+    }
     buildRuntimeDescriptor() {
         const source = this.options.runtimeDescriptor ?? DEFAULT_SDK_RUNTIME_DESCRIPTOR;
         const hasInterrupt = this.hasInterruptSupport();
@@ -677,6 +690,7 @@ export class CanonAgent {
         return {
             ...source,
             supportsInterrupt: hasInterrupt,
+            supportsInputInterrupt: source.supportsInputInterrupt === false ? false : hasInterrupt,
             commands,
             actions,
         };
@@ -685,6 +699,7 @@ export class CanonAgent {
         return {
             ...SDK_RUNTIME_CAPABILITIES,
             supportsInterrupt: this.hasInterruptSupport(),
+            supportsInputInterrupt: this.supportsInputInterrupt(),
             supportsQueue: Boolean(this.sessionManager),
         };
     }
@@ -1049,6 +1064,10 @@ export class CanonAgent {
             if (!runtimeState || !agentId)
                 return;
             turnState = state;
+            const isOpenTurn = state === 'thinking'
+                || state === 'streaming'
+                || state === 'tool'
+                || state === 'waiting_input';
             await Promise.resolve(runtimeState.writeTurnState(conversationId, {
                 turnId,
                 state,
@@ -1056,6 +1075,7 @@ export class CanonAgent {
                 currentSpeakerId: agentId,
                 capabilities: this.buildRuntimeCapabilities(),
                 openedAt: turnOpenedAt,
+                ...(isOpenTurn ? { turnUpdatedAt: Date.now() } : {}),
                 ...(state === 'completed' || state === 'interrupted' || state === 'idle'
                     ? { completedAt: { '.sv': 'timestamp' } }
                     : {}),

package/dist/debouncer.d.ts

@@ -9,6 +9,7 @@ export declare class Debouncer {
     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

@@ -43,6 +43,27 @@ export class Debouncer {
             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;

package/dist/realtime.d.ts

@@ -10,15 +10,20 @@ export declare class RealtimeManager {
     private agentId;
     private stream;
     private running;
+    private lastSseErrorKey;
+    private lastSseErrorAt;
+    private suppressedSseErrorCount;
     private onAgentContext;
     private onContactRequest;
     private onContactApproved;
     private onContactAdded;
     private onContactRemoved;
     private onConversationUpdated;
+    private onMessageDeleted;
     private onConnected;
     private onDisconnected;
     constructor(apiKey: string, debouncer: Debouncer, agentId: string, streamUrl?: string, apiClient?: CanonClient);
+    private logSseError;
     setOnAgentContext(cb: (ctx: AgentContext) => void): void;
     setContactRequestHandlers(handlers: {
         onContactRequest?: (payload: ContactRequestPayload) => void;
@@ -29,6 +34,10 @@ export declare class RealtimeManager {
         onContactRemoved?: (payload: ContactRemovedPayload) => void;
     }): void;
     setConversationUpdatedHandler(cb: (payload: ConversationUpdatedPayload) => void): void;
+    setMessageDeletedHandler(cb: (payload: {
+        conversationId: string;
+        messageId: string;
+    }) => void): void;
     setConnectionHandlers(handlers: {
         onConnected?: () => void;
         onDisconnected?: () => void;

package/dist/realtime.js

@@ -9,12 +9,16 @@ export class RealtimeManager {
     agentId;
     stream;
     running = false;
+    lastSseErrorKey = null;
+    lastSseErrorAt = 0;
+    suppressedSseErrorCount = 0;
     onAgentContext = null;
     onContactRequest = null;
     onContactApproved = null;
     onContactAdded = null;
     onContactRemoved = null;
     onConversationUpdated = null;
+    onMessageDeleted = null;
     onConnected = null;
     onDisconnected = null;
     constructor(apiKey, debouncer, agentId, streamUrl, apiClient) {
@@ -54,6 +58,10 @@ export class RealtimeManager {
                     };
                     this.debouncer.add(payload.conversationId, message, payload.provenance ?? null);
                 },
+                onMessageDeleted: (payload) => {
+                    this.debouncer.removeMessage(payload.conversationId, payload.messageId);
+                    this.onMessageDeleted?.(payload);
+                },
                 onAgentContext: (ctx) => {
                     this.onAgentContext?.(ctx);
                 },
@@ -80,11 +88,27 @@ export class RealtimeManager {
                     this.onDisconnected?.();
                 },
                 onError: (err) => {
-                    console.error('[canon-sdk] SSE error:', err.message);
+                    this.logSseError(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;
     }
@@ -99,6 +123,9 @@ export class RealtimeManager {
     setConversationUpdatedHandler(cb) {
         this.onConversationUpdated = cb;
     }
+    setMessageDeletedHandler(cb) {
+        this.onMessageDeleted = cb;
+    }
     setConnectionHandlers(handlers) {
         this.onConnected = handlers.onConnected ?? null;
         this.onDisconnected = handlers.onDisconnected ?? null;
@@ -110,6 +137,5 @@ export class RealtimeManager {
     stop() {
         this.running = false;
         this.stream.stop();
-        this.onDisconnected?.();
     }
 }

package/dist/session-manager.d.ts

@@ -63,6 +63,8 @@ export declare class SessionManager {
     get sessionCount(): number;
     /** Number of queued batches waiting behind the active turn for this conversation. */
     getQueueDepth(conversationId: string): number;
+    /** Drop one not-yet-running queued message for a conversation. */
+    dropQueuedMessage(conversationId: string, messageId: string): CanonMessage[];
     /** Drop queued, not-yet-running batches for a conversation. */
     dropQueued(conversationId: string): CanonMessage[];
     /** Drop queued work and clear retained context for a conversation. */

package/dist/session-manager.js

@@ -199,6 +199,42 @@ export class SessionManager {
     getQueueDepth(conversationId) {
         return this.queues.get(conversationId)?.length ?? 0;
     }
+    /** Drop one not-yet-running queued message for a conversation. */
+    dropQueuedMessage(conversationId, messageId) {
+        const queue = this.queues.get(conversationId);
+        if (!queue || queue.length === 0)
+            return [];
+        const droppedMessages = [];
+        const nextQueue = [];
+        for (const item of queue) {
+            const keptMessages = item.messages.filter((message) => {
+                const drop = message.id === messageId;
+                if (drop)
+                    droppedMessages.push(message);
+                return !drop;
+            });
+            if (keptMessages.length === 0) {
+                item.resolve();
+            }
+            else if (keptMessages.length !== item.messages.length) {
+                nextQueue.push({ ...item, messages: keptMessages });
+            }
+            else {
+                nextQueue.push(item);
+            }
+        }
+        if (droppedMessages.length === 0)
+            return [];
+        if (nextQueue.length === 0) {
+            this.queues.delete(conversationId);
+            this.pending.delete(conversationId);
+        }
+        else {
+            this.queues.set(conversationId, nextQueue);
+        }
+        this.removeMessagesFromSession(conversationId, droppedMessages);
+        return droppedMessages;
+    }
     /** Drop queued, not-yet-running batches for a conversation. */
     dropQueued(conversationId) {
         const queue = this.queues.get(conversationId);

package/dist/turn-filter.js

@@ -2,7 +2,12 @@ import { evaluateParticipationPolicy, normalizeTurnState, rtdbRead, shouldTrigge
 function normalizeRuntimeTurnState(value) {
     const turnState = normalizeTurnState(value);
     if (turnState) {
-        return { state: turnState.state };
+        return {
+            state: turnState.state,
+            ...(turnState.openedAt !== undefined ? { openedAt: turnState.openedAt } : {}),
+            ...(turnState.updatedAt !== undefined ? { updatedAt: turnState.updatedAt } : {}),
+            ...(turnState.turnUpdatedAt !== undefined ? { turnUpdatedAt: turnState.turnUpdatedAt } : {}),
+        };
     }
     return null;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@canonmsg/agent-sdk",
-  "version": "1.5.1",
+  "version": "1.5.3",
   "description": "Canon Agent SDK — build AI agents that participate in Canon conversations",
   "type": "module",
   "main": "dist/index.js",
@@ -28,7 +28,7 @@
     "node": ">=18.0.0"
   },
   "dependencies": {
-    "@canonmsg/core": "^0.19.2"
+    "@canonmsg/core": "^0.20.0"
   },
   "publishConfig": {
     "access": "public"