@canonmsg/agent-sdk 1.3.1 → 1.4.1

package/dist/canon-agent.d.ts

@@ -1,4 +1,4 @@
-import { type AddMemberResult, type CanonContact, type CanonRuntimePrimitiveId, type ContactCardPayload, type CreateContactRequestResult } from '@canonmsg/core';
+import { type AddMemberResult, type CanonContact, type CanonRuntimeActivityItem, type CanonRuntimeCommandDescriptor, type CanonRuntimeFact, type CanonRuntimePrimitiveId, type ContactCardPayload, type ClearRuntimeActivityOptions, type CreateContactRequestResult } from '@canonmsg/core';
 import type { CanonAgentOptions, ContactAddedHandler, ContactRemovedHandler, CreateConversationOptions, MessageHandler, ReachOutOptions, ReachOutResult, ContactRequestHandler, RuntimeSignalHandler, RuntimePrimitiveHandler } from './types.js';
 /**
  * Contact-graph operations exposed under `agent.contacts`. Wraps the REST
@@ -49,6 +49,7 @@ export declare class CanonAgent {
     private readonly lastSeenSignal;
     private readonly primitiveRequestDedupe;
     private readonly activeAbortControllers;
+    private readonly activeTurns;
     private readonly conversationMemberIds;
     private readonly pendingMembershipChanges;
     constructor(options: CanonAgentOptions);
@@ -61,6 +62,10 @@ export declare class CanonAgent {
     on(event: 'stopAndDrop', handler: RuntimeSignalHandler): void;
     on(event: 'newSession', handler: RuntimeSignalHandler): void;
     onPrimitive(primitive: CanonRuntimePrimitiveId | '*', handler: RuntimePrimitiveHandler): void;
+    describeCommands(_provider?: string): ReadonlyArray<CanonRuntimeCommandDescriptor>;
+    publishRuntimeFacts(conversationId: string, facts: ReadonlyArray<CanonRuntimeFact>): Promise<void>;
+    publishRuntimeActivity(conversationId: string, item: CanonRuntimeActivityItem): Promise<void>;
+    clearRuntimeActivity(conversationId: string, options?: ClearRuntimeActivityOptions): Promise<void>;
     /**
      * Resolve admission live for a target user (typically read off a shared
      * contact card) and route into either an immediate message or a contact
@@ -124,10 +129,13 @@ export declare class CanonAgent {
     private clearRuntimePrimitiveRequest;
     private prunePrimitiveRequestDedupe;
     private handleRuntimeSignal;
+    private firstActiveTurn;
+    private publishAcceptedRuntimeSignal;
     private abortActiveTurns;
     private resolveBatchDeliveryIntent;
     private notifyMessageInterrupt;
     private createRuntimeStatePublisher;
+    private requireRuntimeStatePublisher;
     private handleMessages;
     private executeHandler;
     static register(options: {

package/dist/canon-agent.js

@@ -1,8 +1,8 @@
-import { CanonClient, buildCanonGroupContext, createRuntimeStatePublisher, diffCanonMemberIds, FINAL_MESSAGE_HANDOFF_MS, RUNTIME_NEW_SESSION_ACTION, RUNTIME_STOP_ACTION, RUNTIME_STOP_AND_DROP_ACTION, initRTDBAuth, rtdbRead, rtdbWrite, normalizeTurnMetadata, reachOutToCanonContact, resolveMessageActiveSelfContextId, selectActiveSelfContexts, } from '@canonmsg/core';
+import { CanonClient, buildCanonGroupContext, createRuntimeStatePublisher, diffCanonMemberIds, FINAL_MESSAGE_HANDOFF_MS, RUNTIME_NEW_SESSION_ACTION, RUNTIME_STOP_ACTION, RUNTIME_STOP_AND_DROP_ACTION, initRTDBAuth, rtdbRead, rtdbWrite, normalizeTurnMetadata, reachOutToCanonContact, resolveCanonReplyContext, resolveMessageActiveSelfContextId, selectActiveSelfContexts, } from '@canonmsg/core';
 import { randomUUID } from 'node:crypto';
 import { AuthManager } from './auth.js';
 import { Debouncer } from './debouncer.js';
-import { materializeMessageMedia, sendMediaFileMessage, uploadMediaFile, } from './media.js';
+import { materializeMessageMedia, materializeReplyContextMedia, sendMediaFileMessage, uploadMediaFile, } from './media.js';
 import { SessionManager } from './session-manager.js';
 const AGENT_RUNTIME_HEARTBEAT_MS = 30_000;
 const RUNTIME_PRIMITIVE_DEDUPE_TTL_MS = 5 * 60 * 1000;
@@ -147,6 +147,40 @@ function normalizePrimitiveArgs(value) {
     }
     return args;
 }
+function normalizeRuntimeFact(fact) {
+    const id = fact.id.trim();
+    const label = fact.label.trim();
+    const value = fact.value.trim();
+    if (!id || !label || !value)
+        return null;
+    return {
+        ...fact,
+        id,
+        label,
+        value,
+    };
+}
+function normalizeRuntimeActivityItem(item) {
+    return {
+        ...item,
+        id: item.id.trim(),
+        title: item.title.trim() || item.kind,
+        updatedAt: item.updatedAt || Date.now(),
+    };
+}
+function createTurnAbortError() {
+    const error = new Error('Canon turn was interrupted before reply delivery.');
+    error.name = 'AbortError';
+    return error;
+}
+function isAbortLikeError(error) {
+    if (!error || typeof error !== 'object')
+        return false;
+    const record = error;
+    if (record.name === 'AbortError' || record.code === 'ABORT_ERR')
+        return true;
+    return typeof record.message === 'string' && /\babort(?:ed)?\b/i.test(record.message);
+}
 export class CanonAgent {
     options;
     apiClient;
@@ -178,6 +212,7 @@ export class CanonAgent {
     lastSeenSignal = new Map();
     primitiveRequestDedupe = new Map();
     activeAbortControllers = new Map();
+    activeTurns = new Map();
     conversationMemberIds = new Map();
     pendingMembershipChanges = new Map();
     constructor(options) {
@@ -283,6 +318,32 @@ export class CanonAgent {
         }
         void this.publishAgentRuntime().catch(() => { });
     }
+    describeCommands(_provider) {
+        return this.buildRuntimeDescriptor().commands ?? [];
+    }
+    async publishRuntimeFacts(conversationId, facts) {
+        this.rememberConversationId(conversationId);
+        const publisher = this.requireRuntimeStatePublisher();
+        const normalizedFacts = facts
+            .map(normalizeRuntimeFact)
+            .filter((fact) => Boolean(fact));
+        await publisher.patchRuntimeInfo(conversationId, {
+            descriptor: this.buildRuntimeDescriptor(),
+            facts: normalizedFacts,
+        });
+    }
+    async publishRuntimeActivity(conversationId, item) {
+        this.rememberConversationId(conversationId);
+        const normalized = normalizeRuntimeActivityItem(item);
+        if (!normalized.id) {
+            throw new Error('Runtime activity item id is required.');
+        }
+        await this.requireRuntimeStatePublisher().writeRuntimeActivity(conversationId, normalized);
+    }
+    async clearRuntimeActivity(conversationId, options) {
+        this.rememberConversationId(conversationId);
+        await this.requireRuntimeStatePublisher().clearRuntimeActivity(conversationId, options);
+    }
     /**
      * Resolve admission live for a target user (typically read off a shared
      * contact card) and route into either an immediate message or a contact
@@ -785,6 +846,7 @@ export class CanonAgent {
             await Promise.resolve(rtdbWrite(`/control/${conversationId}/${this.agentId}/signal`, null)).catch(() => { });
             return;
         }
+        const activeTurn = this.firstActiveTurn(conversationId);
         const abortSignal = this.abortActiveTurns(conversationId);
         const droppedMessages = signal === 'new_session'
             ? this.sessionManager?.resetSession(conversationId) ?? []
@@ -797,6 +859,10 @@ export class CanonAgent {
                 return Promise.resolve();
             return this.apiClient.updateMessageDisposition(conversationId, message.id, 'rejected').catch(() => { });
         }));
+        await this.publishAcceptedRuntimeSignal(conversationId, signal, activeTurn, {
+            hasActiveTurn: Boolean(abortSignal),
+            droppedCount: droppedMessages.length,
+        });
         await Promise.resolve(handler?.({
             conversationId,
             signal: signal,
@@ -808,6 +874,39 @@ export class CanonAgent {
         });
         await Promise.resolve(rtdbWrite(`/control/${conversationId}/${this.agentId}/signal`, null)).catch(() => { });
     }
+    firstActiveTurn(conversationId) {
+        const turns = this.activeTurns.get(conversationId);
+        if (!turns || turns.size === 0)
+            return null;
+        return turns.values().next().value ?? null;
+    }
+    async publishAcceptedRuntimeSignal(conversationId, signal, activeTurn, outcome) {
+        if (!this.agentId)
+            return;
+        const shouldPublishInterrupted = signal === 'interrupt'
+            || signal === 'stop_and_drop'
+            || outcome.hasActiveTurn
+            || outcome.droppedCount > 0;
+        const runtimeState = shouldPublishInterrupted
+            ? this.createRuntimeStatePublisher()
+            : null;
+        if (runtimeState) {
+            await Promise.resolve(runtimeState.writeTurnState(conversationId, {
+                turnId: activeTurn?.turnId ?? null,
+                state: 'interrupted',
+                queueDepth: this.sessionManager?.getQueueDepth(conversationId) ?? 0,
+                currentSpeakerId: this.agentId,
+                activeMessageIds: activeTurn?.activeMessageIds ?? [],
+                capabilities: this.buildRuntimeCapabilities(),
+                ...(activeTurn?.openedAt ? { openedAt: activeTurn.openedAt } : {}),
+                completedAt: { '.sv': 'timestamp' },
+            })).catch(() => { });
+        }
+        await Promise.all([
+            this.apiClient.clearStreaming(conversationId).catch(() => { }),
+            this.apiClient.setTyping(conversationId, false).catch(() => { }),
+        ]);
+    }
     abortActiveTurns(conversationId) {
         const controllers = this.activeAbortControllers.get(conversationId);
         if (!controllers || controllers.size === 0)
@@ -844,6 +943,13 @@ export class CanonAgent {
             hostMode: false,
         });
     }
+    requireRuntimeStatePublisher() {
+        const publisher = this.createRuntimeStatePublisher();
+        if (!publisher) {
+            throw new Error('Canon agent must be started before publishing runtime operations.');
+        }
+        return publisher;
+    }
     async handleMessages(conversationId, messages) {
         if (!this.handler) {
             console.warn(`[canon-sdk] No message handler registered — messages for ${conversationId} dropped. Call agent.on('message', handler) before starting.`);
@@ -873,9 +979,21 @@ export class CanonAgent {
         const runtimeState = this.createRuntimeStatePublisher();
         const queueDepth = () => this.sessionManager?.getQueueDepth(conversationId) ?? 0;
         const abortController = new AbortController();
+        const throwIfAborted = () => {
+            if (abortController.signal.aborted) {
+                throw createTurnAbortError();
+            }
+        };
         const activeControllers = this.activeAbortControllers.get(conversationId) ?? new Set();
         activeControllers.add(abortController);
         this.activeAbortControllers.set(conversationId, activeControllers);
+        const activeTurns = this.activeTurns.get(conversationId) ?? new Map();
+        activeTurns.set(abortController, {
+            turnId,
+            openedAt: turnOpenedAt,
+            activeMessageIds: messages.map((message) => message.id).filter(Boolean),
+        });
+        this.activeTurns.set(conversationId, activeTurns);
         const writeTurn = async (state) => {
             if (!runtimeState || !agentId)
                 return;
@@ -893,6 +1011,7 @@ export class CanonAgent {
             })).catch(() => { });
         };
         const setLiveState = async (state, text, streamingStatus) => {
+            throwIfAborted();
             await writeTurn(state);
             if (streamingStatus) {
                 try {
@@ -953,10 +1072,12 @@ export class CanonAgent {
                 return;
             // Build reply functions
             const replyFinal = async (text, options) => {
+                throwIfAborted();
                 try {
                     await this.apiClient.setTyping(conversationId, true, 'typing');
                 }
                 catch { }
+                throwIfAborted();
                 const sendOptions = withActiveSelfContext(options);
                 const result = await this.apiClient.sendMessage(conversationId, text, {
                     ...sendOptions,
@@ -975,10 +1096,12 @@ export class CanonAgent {
                 return result;
             };
             const replyProgress = async (text, options) => {
+                throwIfAborted();
                 await setLiveState('streaming', text, 'streaming');
                 if (!options?.durable) {
                     return { turnId, durable: false, messageId: null };
                 }
+                throwIfAborted();
                 const { durable: _durable, ...sendOptions } = options;
                 const sendOptionsWithContext = withActiveSelfContext(sendOptions);
                 const result = await this.apiClient.sendMessage(conversationId, text, {
@@ -1000,6 +1123,9 @@ export class CanonAgent {
                 }
             }
             const latestMessage = hydratedMessages[hydratedMessages.length - 1] ?? null;
+            let replyContext = latestMessage
+                ? resolveCanonReplyContext({ message: latestMessage, messages: history })
+                : null;
             const resolvedActiveSelfContextId = resolveMessageActiveSelfContextId({
                 messageId: latestMessage?.id,
                 activeSelfContextIdByMessageId: page.activeSelfContextIdByMessageId,
@@ -1021,6 +1147,18 @@ export class CanonAgent {
                 inboundPolicy: 'approval-required',
                 groupJoinPolicy: 'approval-required',
             };
+            if (replyContext?.found && replyContext.attachments?.length) {
+                try {
+                    const materializedReply = await materializeReplyContextMedia(replyContext, {
+                        agentId: agent.agentId,
+                        conversationId,
+                    });
+                    replyContext = materializedReply.replyContext;
+                }
+                catch (error) {
+                    console.error(`[canon-sdk] Failed to materialize reply context media for ${conversationId}:`, error instanceof Error ? error.message : error);
+                }
+            }
             const membershipChange = this.pendingMembershipChanges.get(conversationId) ?? null;
             this.pendingMembershipChanges.delete(conversationId);
             const groupContext = this.buildGroupContext({
@@ -1058,10 +1196,12 @@ export class CanonAgent {
             });
             const uploadFile = (filePath, options) => uploadMediaFile(this.apiClient, conversationId, filePath, options);
             const replyWithFile = async (filePath, text = '', options) => {
+                throwIfAborted();
                 try {
                     await this.apiClient.setTyping(conversationId, true, 'typing');
                 }
                 catch { }
+                throwIfAborted();
                 try {
                     const result = await sendMediaFileMessage(this.apiClient, conversationId, filePath, text, {
                         ...(options?.replyTo ? { replyTo: options.replyTo } : {}),
@@ -1093,9 +1233,11 @@ export class CanonAgent {
                 }
             };
             // Invoke handler
+            throwIfAborted();
             await this.handler({
                 messages: hydratedMessages,
                 history,
+                replyContext,
                 conversationId,
                 conversation,
                 ...(groupContext ? { groupContext } : {}),
@@ -1182,6 +1324,10 @@ export class CanonAgent {
             }
         }
         catch (err) {
+            if (abortController.signal.aborted || isAbortLikeError(err)) {
+                await writeTurn('interrupted');
+                return;
+            }
             console.error(`[canon-sdk] Handler error for ${conversationId}:`, err);
             await writeTurn('interrupted');
         }
@@ -1191,6 +1337,11 @@ export class CanonAgent {
             if (activeControllers?.size === 0) {
                 this.activeAbortControllers.delete(conversationId);
             }
+            const activeTurns = this.activeTurns.get(conversationId);
+            activeTurns?.delete(abortController);
+            if (activeTurns?.size === 0) {
+                this.activeTurns.delete(conversationId);
+            }
             clearInterval(thinkingKeepalive);
             // Always clear typing when done
             try {

package/dist/index.d.ts

@@ -1,10 +1,10 @@
 export { CanonAgent } from './canon-agent.js';
 export type { AgentContactsAPI, AgentUsersAPI } from './canon-agent.js';
 export { CanonApiError, HOST_ADMISSION_ACTION_CAPABILITIES, HOST_ADMISSION_ACTIONS_DISABLED, } from '@canonmsg/core';
-export type { CanonContact, CanonResolveAdmissionResult, ContactAddedPayload, ContactCardPayload, ContactRemovedPayload, ContactSource, HostAdmissionActionCapabilities, ResolvedAdmissionState, ResolvedAdmissionTargetSummary, ResolvedTargetAdmissionPayload, } from '@canonmsg/core';
+export type { CanonContact, CanonRuntimeActivityItem, CanonRuntimeActivityKind, CanonRuntimeActivityStatus, CanonRuntimeFact, CanonRuntimeFactGroup, CanonResolveAdmissionResult, ContactAddedPayload, ContactCardPayload, ContactRemovedPayload, ContactSource, HostAdmissionActionCapabilities, ResolvedAdmissionState, ResolvedAdmissionTargetSummary, ResolvedTargetAdmissionPayload, } from '@canonmsg/core';
 export { SessionManager } from './session-manager.js';
-export { DEFAULT_MEDIA_CACHE_DIR, getCodexImagePath, getMessageAttachments, inferUploadMimeType, isAnthropicImageAttachment, materializeAttachment, materializeMessageMedia, resolveAttachmentMimeType, sendMediaFileMessage, toAnthropicImageBlock, uploadMediaFile, } from './media.js';
-export type { AnthropicImageBlock, AnthropicImageMimeType, MaterializeMediaOptions, MaterializedCanonAttachment, ReplyWithFileOptions, UploadMediaFileOptions, } from './media.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, CanonSelfContext, SendContextualMessageOptions, SendContextualMessageResult, SendContextualSelfContextInput, SendMessageOptions, CreateConversationOptions, } from '@canonmsg/core';
+export type { AgentContext, CanonGroupContext, CanonKnownRecentParticipant, CanonMembershipChange, CanonContactRequest, CanonMessage, CanonConversation, CanonReplyContext, CanonSelfContext, SendContextualMessageOptions, SendContextualMessageResult, SendContextualSelfContextInput, SendMessageOptions, CreateConversationOptions, } from '@canonmsg/core';
 export type { CanonAgentOptions, ContactAddedHandler, ContactRemovedHandler, ContactRequestHandler, MessageHandler, MessageHandlerContext, ProgressMessageOptions, ProgressMessageResult, ReachOutOptions, ReachOutResult, RuntimePrimitiveContext, RuntimePrimitiveHandler, RuntimePrimitiveHandlers, SessionInfo, SessionOptions, DeliveryMode, } from './types.js';

package/dist/index.js

@@ -1,4 +1,4 @@
 export { CanonAgent } from './canon-agent.js';
 export { CanonApiError, HOST_ADMISSION_ACTION_CAPABILITIES, HOST_ADMISSION_ACTIONS_DISABLED, } from '@canonmsg/core';
 export { SessionManager } from './session-manager.js';
-export { DEFAULT_MEDIA_CACHE_DIR, getCodexImagePath, getMessageAttachments, inferUploadMimeType, isAnthropicImageAttachment, materializeAttachment, materializeMessageMedia, resolveAttachmentMimeType, sendMediaFileMessage, toAnthropicImageBlock, uploadMediaFile, } from './media.js';
+export { DEFAULT_MEDIA_CACHE_DIR, getCodexImagePath, getMessageAttachments, inferUploadMimeType, isAnthropicImageAttachment, materializeAttachment, materializeMessageMedia, materializeReplyContextMedia, resolveAttachmentMimeType, sendMediaFileMessage, toAnthropicImageBlock, uploadMediaFile, } from './media.js';

package/dist/media.d.ts

@@ -1,4 +1,4 @@
-import { CanonClient, type CanonMessage, type MediaAttachment, type SendMessageOptions } from '@canonmsg/core';
+import { CanonClient, type CanonReplyContext, type CanonMessage, type MediaAttachment, type SendMessageOptions } from '@canonmsg/core';
 export interface MaterializeMediaOptions {
     agentId: string;
     conversationId: string;
@@ -21,6 +21,10 @@ export interface MaterializedCanonAttachment extends MediaAttachment {
     conversationId: string;
     messageId: string;
 }
+export interface MaterializedCanonReplyContext {
+    replyContext: CanonReplyContext | null;
+    materialized: MaterializedCanonAttachment[];
+}
 /**
  * Anthropic `image` content blocks only accept these MIME types for
  * base64 sources. Anything outside this set must either be re-encoded or
@@ -46,6 +50,7 @@ export declare function materializeAttachment(attachment: MediaAttachment, optio
     index?: number;
 }): Promise<MaterializedCanonAttachment>;
 export declare function materializeMessageMedia(message: Pick<CanonMessage, 'id' | 'attachments'>, options: Omit<MaterializeMediaOptions, 'messageId'>): Promise<MaterializedCanonAttachment[]>;
+export declare function materializeReplyContextMedia(replyContext: CanonReplyContext | null, options: Omit<MaterializeMediaOptions, 'messageId'>): Promise<MaterializedCanonReplyContext>;
 export declare function inferUploadMimeType(filePath: string, overrideMimeType?: string): string;
 export declare function uploadMediaFile(client: CanonClient, conversationId: string, filePath: string, options?: UploadMediaFileOptions): Promise<{
     url: string;

package/dist/media.js

@@ -1,6 +1,6 @@
 import { mkdir, readFile, stat, writeFile } from 'node:fs/promises';
 import { basename, dirname, extname, join } from 'node:path';
-import { CANON_DIR, } from '@canonmsg/core';
+import { CANON_DIR, renderCanonHostInboundContent, } from '@canonmsg/core';
 const ANTHROPIC_IMAGE_MIME_TYPES = new Set([
     'image/jpeg',
     'image/png',
@@ -141,6 +141,31 @@ export async function materializeMessageMedia(message, options) {
         index,
     })));
 }
+export async function materializeReplyContextMedia(replyContext, options) {
+    if (!replyContext?.found || !replyContext.attachments?.length) {
+        return { replyContext, materialized: [] };
+    }
+    const materialized = (await Promise.all(replyContext.attachments.map((attachment, index) => attachment.url
+        ? materializeAttachment(attachment, {
+            ...options,
+            messageId: replyContext.messageId,
+            index,
+        })
+        : Promise.resolve(null)))).filter((attachment) => attachment !== null);
+    return {
+        replyContext: {
+            ...replyContext,
+            body: renderCanonHostInboundContent({
+                text: replyContext.text,
+                contentType: replyContext.contentType,
+                attachments: replyContext.attachments,
+                contactCard: replyContext.contactCard,
+                senderType: replyContext.senderType ?? undefined,
+            }, materialized),
+        },
+        materialized,
+    };
+}
 export function inferUploadMimeType(filePath, overrideMimeType) {
     if (overrideMimeType)
         return overrideMimeType;

package/dist/types.d.ts

@@ -1,5 +1,5 @@
-export type { AddMemberResult, AgentClientType, CanonGroupContext, CanonRuntimeDescriptor, CanonRuntimePrimitiveId, CanonMessage, CanonConversation, CanonContact, CanonContactRequest, CanonResolveAdmissionResult, ContactAddedPayload, ContactRemovedPayload, ContactSource, AgentContext, ResolvedAdmissionState, ResolvedAdmissionTargetSummary, ResolvedTargetAdmissionPayload, CanonSelfContext, SendContextualMessageOptions, SendContextualMessageResult, SendContextualSelfContextInput, SendMessageOptions, SessionConfig, CreateConversationOptions, TurnLifecycleState, } from '@canonmsg/core';
-import type { AddMemberResult, CanonGroupContext, CanonMessage, CanonConversation, ContactCardPayload, CanonRuntimeActionDispatch, CanonRuntimePrimitiveId, SendMessageOptions, SendContextualSelfContextInput, SessionConfig } from '@canonmsg/core';
+export type { AddMemberResult, AgentClientType, CanonGroupContext, CanonRuntimeActivityItem, CanonRuntimeActivityKind, CanonRuntimeActivityStatus, CanonRuntimeDescriptor, CanonRuntimeFact, CanonRuntimeFactGroup, CanonRuntimePrimitiveId, CanonMessage, CanonConversation, CanonReplyContext, CanonContact, CanonContactRequest, CanonResolveAdmissionResult, ContactAddedPayload, ContactRemovedPayload, ContactSource, AgentContext, ResolvedAdmissionState, ResolvedAdmissionTargetSummary, ResolvedTargetAdmissionPayload, CanonSelfContext, SendContextualMessageOptions, SendContextualMessageResult, SendContextualSelfContextInput, SendMessageOptions, SessionConfig, CreateConversationOptions, TurnLifecycleState, } from '@canonmsg/core';
+import type { AddMemberResult, CanonGroupContext, CanonMessage, CanonConversation, CanonReplyContext, ContactCardPayload, CanonRuntimeActionDispatch, CanonRuntimePrimitiveId, SendMessageOptions, SendContextualSelfContextInput, SessionConfig } from '@canonmsg/core';
 import type { MaterializeMediaOptions, MaterializedCanonAttachment, ReplyWithFileOptions, UploadMediaFileOptions } from './media.js';
 export interface ProgressMessageOptions extends SendMessageOptions {
     /**
@@ -37,6 +37,8 @@ export interface TurnController {
 export interface MessageHandlerContext {
     messages: CanonMessage[];
     history: CanonMessage[];
+    /** Resolved message/media content for the latest swipe-reply target, if any. */
+    replyContext: CanonReplyContext | null;
     conversationId: string;
     conversation: CanonConversation;
     /** Lightweight group awareness, present for group conversations. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@canonmsg/agent-sdk",
-  "version": "1.3.1",
+  "version": "1.4.1",
   "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.17.2"
+    "@canonmsg/core": "^0.18.1"
   },
   "publishConfig": {
     "access": "public"