@canonmsg/claude-code-plugin 0.3.0 → 0.4.0

package/dist/host.js

@@ -25,7 +25,8 @@ import { parseArgs } from 'node:util';
 import { randomUUID } from 'node:crypto';
 import { basename, resolve } from 'node:path';
 import { query } from '@anthropic-ai/claude-agent-sdk';
-import { CanonClient, CanonStream, resolveCanonAgent, getActiveProfile, releaseLock, initRTDBAuth, rtdbRead, rtdbWrite, writeSessionState, clearSessionState, } from '@canonmsg/core';
+import { CanonClient, CanonStream, clearTurnState, DEFAULT_RUNTIME_CAPABILITIES, normalizeTurnMetadata, resolveCanonAgent, getActiveProfile, releaseLock, initRTDBAuth, rtdbRead, rtdbWrite, writeSessionState, clearSessionState, writeTurnState, } from '@canonmsg/core';
+import { buildInboundContextLines, decideAutoReply, } from './inbound-policy.js';
 let workingDir = process.cwd();
 let workspaceOptions = [];
 let runtimeModels = [];
@@ -124,18 +125,25 @@ const STREAMING_THROTTLE_MS = 250;
 const HEARTBEAT_MS = 30_000;
 const IDLE_CHECK_MS = 60_000;
 const CONTROL_POLL_MS = 2000;
+const COMPLETED_STATE_HOLD_MS = 750;
+const CLAUDE_RUNTIME_CAPABILITIES = {
+    ...DEFAULT_RUNTIME_CAPABILITIES,
+    supportsInterrupt: true,
+    supportsQueue: true,
+    supportsInterleave: true,
+    supportsRequiresAction: true,
+    supportsNonFinalPermanentMessages: true,
+};
 function buildCanonPrompt(input) {
-    const ownerLine = input.isOwner
-        ? 'The sender is the verified human owner of this Canon agent.'
-        : 'The sender is a Canon user in this conversation.';
     return [
         'You are connected to Canon messaging through a Claude Code host wrapper.',
-        'Reply naturally to the Canon user.',
+        'Reply naturally to Canon participants.',
         'Only the last assistant message from this turn will be delivered as the permanent Canon reply.',
         'Short intermediate assistant messages may be shown as ephemeral status while you work.',
-        ownerLine,
+        ...buildInboundContextLines(input.participantContext),
+        'Canon participants may be humans or AI agents.',
+        'If the latest message came from another AI agent, avoid agent-only ping-pong and only reply when directly addressed, when a human is clearly steering, or when a reply is genuinely necessary.',
         `Conversation ID: ${input.conversationId}`,
-        `Sender: ${input.senderName}`,
         '',
         'New Canon message:',
         input.content,
@@ -143,7 +151,25 @@ function buildCanonPrompt(input) {
 }
 function renderInboundContent(message) {
     let content = message.text || '';
-    if (message.contentType === 'audio' && message.audioUrl) {
+    const attachment = message.attachments?.[0];
+    if (attachment?.kind === 'audio' && attachment.url) {
+        const duration = attachment.durationMs ? ` (${Math.round(attachment.durationMs / 1000)}s)` : '';
+        content = content
+            ? `[Voice message${duration}: ${attachment.url}]\n${content}`
+            : `[Voice message${duration}: ${attachment.url}]`;
+    }
+    else if (attachment?.kind === 'image' && attachment.url) {
+        content = content
+            ? `[Image: ${attachment.url}]\n${content}`
+            : `[Image: ${attachment.url}]`;
+    }
+    else if (attachment?.kind === 'file' && attachment.url) {
+        const label = attachment.fileName || 'File';
+        content = content
+            ? `[File: ${label} ${attachment.url}]\n${content}`
+            : `[File: ${label} ${attachment.url}]`;
+    }
+    else if (message.contentType === 'audio' && message.audioUrl) {
         const duration = message.audioDurationMs ? ` (${Math.round(message.audioDurationMs / 1000)}s)` : '';
         content = content
             ? `[Voice message${duration}: ${message.audioUrl}]\n${content}`
@@ -173,6 +199,9 @@ function createSession(conversationId, cwd, agentId, client, onSessionEnd, confi
             messageQueue.push(msg);
         }
     };
+    let enqueueInboundMessage = (msg, _intent = 'queue', _sourceMessageId, _markAccepted = false) => {
+        sendInput(msg);
+    };
     const inputStream = {
         [Symbol.asyncIterator]() {
             return {
@@ -232,6 +261,8 @@ function createSession(conversationId, cwd, agentId, client, onSessionEnd, confi
                             type: 'claude_question',
                             questionId,
                             questions,
+                            turnSemantics: 'control',
+                            replyBehavior: 'suppress_auto_reply',
                         },
                     });
                     console.error(`[canon-host] [${conversationId.slice(0, 8)}] Question sent (${questionId.slice(0, 8)})`);
@@ -249,7 +280,12 @@ function createSession(conversationId, cwd, agentId, client, onSessionEnd, confi
                 try {
                     const planId = randomUUID();
                     await client.sendMessage(conversationId, 'Plan ready for review.', {
-                        metadata: { type: 'plan_approval', planId },
+                        metadata: {
+                            type: 'plan_approval',
+                            planId,
+                            turnSemantics: 'control',
+                            replyBehavior: 'suppress_auto_reply',
+                        },
                     });
                     console.error(`[canon-host] [${conversationId.slice(0, 8)}] Plan approval sent (${planId.slice(0, 8)})`);
                     const reply = await waitForReply();
@@ -281,6 +317,7 @@ function createSession(conversationId, cwd, agentId, client, onSessionEnd, confi
         cwd,
         query: q,
         sendInput,
+        enqueueInbound: (msg, intent = 'queue', sourceMessageId, markAccepted = false) => enqueueInboundMessage(msg, intent, sourceMessageId, markAccepted),
         state: {
             model: config.model,
             permissionMode: config.permissionMode,
@@ -289,7 +326,15 @@ function createSession(conversationId, cwd, agentId, client, onSessionEnd, confi
         availableModels: config.availableModels,
         streamingText: '',
         streamingTimer: null,
+        idleResetTimer: null,
         seedResponseHandled: !!resumeSessionId, // Resumed sessions don't need seed handling
+        pendingInputs: [],
+        pendingFinalText: null,
+        toolInProgress: false,
+        turnState: 'idle',
+        currentTurnId: null,
+        currentTurnOpenedAt: null,
+        lastAcceptedIntent: null,
         lastActivity: Date.now(),
         closed: false,
         sdkSessionId: resumeSessionId || null,
@@ -322,6 +367,31 @@ function createSession(conversationId, cwd, agentId, client, onSessionEnd, confi
         session.streamingText = '';
         rtdbWrite(`/streaming/${conversationId}/${agentId}`, null).catch(() => { });
     }
+    function clearIdleResetTimer() {
+        if (!session.idleResetTimer)
+            return;
+        clearTimeout(session.idleResetTimer);
+        session.idleResetTimer = null;
+    }
+    function resetTurnToIdle() {
+        if (session.closed)
+            return;
+        session.currentTurnId = null;
+        session.currentTurnOpenedAt = null;
+        session.lastAcceptedIntent = null;
+        session.pendingFinalText = null;
+        session.toolInProgress = false;
+        session.turnState = 'idle';
+        writeTurn();
+        drainPendingInput();
+    }
+    function scheduleIdleTurnReset() {
+        clearIdleResetTimer();
+        session.idleResetTimer = setTimeout(() => {
+            session.idleResetTimer = null;
+            resetTurnToIdle();
+        }, COMPLETED_STATE_HOLD_MS);
+    }
     function writeState() {
         writeSessionState(conversationId, agentId, {
             ...session.state,
@@ -331,6 +401,56 @@ function createSession(conversationId, cwd, agentId, client, onSessionEnd, confi
             isActive: true,
         }).catch(() => { });
     }
+    function writeTurn() {
+        writeTurnState(conversationId, agentId, {
+            turnId: session.currentTurnId,
+            state: session.turnState,
+            queueDepth: session.pendingInputs.length,
+            currentSpeakerId: agentId,
+            lastAcceptedIntent: session.lastAcceptedIntent,
+            capabilities: CLAUDE_RUNTIME_CAPABILITIES,
+            ...(session.currentTurnOpenedAt ? { openedAt: session.currentTurnOpenedAt } : {}),
+            ...(session.turnState === 'idle' || session.turnState === 'completed' || session.turnState === 'interrupted'
+                ? { completedAt: { '.sv': 'timestamp' } }
+                : {}),
+        }).catch(() => { });
+    }
+    async function markQueuedMessageAccepted(sourceMessageId, markAccepted) {
+        if (!markAccepted || !sourceMessageId)
+            return;
+        await client.updateMessageDisposition(conversationId, sourceMessageId, 'accepted_now').catch(() => { });
+    }
+    function drainPendingInput() {
+        if (session.closed || session.state.state === 'running' || session.pendingInputs.length === 0)
+            return;
+        const next = session.pendingInputs.shift();
+        if (!next)
+            return;
+        session.lastAcceptedIntent = next.intent;
+        writeTurn();
+        void markQueuedMessageAccepted(next.sourceMessageId, next.markAccepted)
+            .finally(() => sendInput(next.msg));
+    }
+    enqueueInboundMessage = (msg, intent = 'queue', sourceMessageId = null, markAccepted = false) => {
+        session.lastActivity = Date.now();
+        if (session.state.state === 'running' && intent !== 'interrupt') {
+            session.pendingInputs.push({ msg, intent, sourceMessageId, markAccepted });
+            writeTurn();
+            return;
+        }
+        if (session.state.state === 'running' && intent === 'interrupt') {
+            session.pendingInputs.unshift({ msg, intent, sourceMessageId, markAccepted });
+            session.turnState = 'interrupted';
+            writeTurn();
+            void session.query.interrupt().catch(() => { });
+            return;
+        }
+        session.lastAcceptedIntent = intent;
+        writeTurn();
+        void markQueuedMessageAccepted(sourceMessageId, markAccepted)
+            .finally(() => sendInput(msg));
+    };
+    writeTurn();
     // ── Process SDK output messages ──
     const processMessages = async () => {
         try {
@@ -353,19 +473,28 @@ function createSession(conversationId, cwd, agentId, client, onSessionEnd, confi
                         const fullText = textBlocks.join('\n').trim();
                         clearStreaming();
                         if (fullText) {
-                            try {
-                                await client.sendMessage(conversationId, fullText);
-                                console.error(`[canon-host] [${conversationId.slice(0, 8)}] Sent reply (${fullText.length} chars)`);
-                            }
-                            catch (err) {
-                                console.error(`[canon-host] [${conversationId.slice(0, 8)}] Failed to send reply:`, err);
-                            }
+                            session.pendingFinalText = fullText;
                         }
                         break;
                     }
                     case 'stream_event': {
                         const event = msg.event;
-                        if (event?.type === 'content_block_delta' && event.delta?.type === 'text_delta') {
+                        if (event?.type === 'content_block_start' && event.content_block?.type === 'tool_use') {
+                            session.toolInProgress = true;
+                            session.turnState = 'tool';
+                            writeTurn();
+                        }
+                        else if (event?.type === 'content_block_stop' && session.toolInProgress) {
+                            session.toolInProgress = false;
+                            if (session.state.state === 'running') {
+                                session.turnState = 'thinking';
+                                writeTurn();
+                            }
+                        }
+                        else if (event?.type === 'content_block_delta' && event.delta?.type === 'text_delta') {
+                            session.toolInProgress = false;
+                            session.turnState = 'streaming';
+                            writeTurn();
                             onStreamDelta(event.delta.text);
                         }
                         break;
@@ -376,16 +505,36 @@ function createSession(conversationId, cwd, agentId, client, onSessionEnd, confi
                             const state = msg.state;
                             session.state.state = state;
                             if (state === 'running') {
+                                clearIdleResetTimer();
+                                if (!session.currentTurnId) {
+                                    session.currentTurnId = randomUUID();
+                                    session.currentTurnOpenedAt = Date.now();
+                                }
+                                session.pendingFinalText = null;
+                                session.toolInProgress = false;
+                                session.turnState = 'thinking';
                                 client.setTyping(conversationId, true, 'thinking').catch(() => { });
                             }
                             else if (state === 'idle') {
+                                clearIdleResetTimer();
+                                session.turnState = 'completed';
                                 client.setTyping(conversationId, false).catch(() => { });
                                 clearStreaming();
+                                writeTurn();
+                                scheduleIdleTurnReset();
                             }
                             else if (state === 'requires_action') {
+                                clearIdleResetTimer();
+                                if (!session.currentTurnId) {
+                                    session.currentTurnId = randomUUID();
+                                    session.currentTurnOpenedAt = Date.now();
+                                }
+                                session.toolInProgress = false;
+                                session.turnState = 'waiting_input';
                                 client.setTyping(conversationId, false).catch(() => { });
                             }
                             writeState();
+                            writeTurn();
                         }
                         break;
                     }
@@ -395,6 +544,26 @@ function createSession(conversationId, cwd, agentId, client, onSessionEnd, confi
                         if (resultSessionId)
                             session.sdkSessionId = resultSessionId;
                         console.error(`[canon-host] [${conversationId.slice(0, 8)}] Turn complete (${msg.subtype})`);
+                        const resultText = typeof msg.result === 'string'
+                            ? msg.result.trim()
+                            : '';
+                        const finalText = resultText || session.pendingFinalText?.trim() || null;
+                        if (finalText) {
+                            try {
+                                await client.sendMessage(conversationId, finalText, {
+                                    metadata: {
+                                        turnId: session.currentTurnId,
+                                        turnSemantics: 'turn_complete',
+                                        turnComplete: true,
+                                        deliveryIntent: session.lastAcceptedIntent ?? undefined,
+                                    },
+                                });
+                                console.error(`[canon-host] [${conversationId.slice(0, 8)}] Sent final reply (${finalText.length} chars)`);
+                            }
+                            catch (err) {
+                                console.error(`[canon-host] [${conversationId.slice(0, 8)}] Failed to send final reply:`, err);
+                            }
+                        }
                         try {
                             const usage = await q.getContextUsage();
                             writeSessionState(conversationId, agentId, {
@@ -413,6 +582,9 @@ function createSession(conversationId, cwd, agentId, client, onSessionEnd, confi
                         catch {
                             // Non-fatal
                         }
+                        if (session.state.state !== 'running' && !session.idleResetTimer) {
+                            drainPendingInput();
+                        }
                         break;
                     }
                     default:
@@ -544,6 +716,59 @@ async function main() {
     const pendingSessionCreations = new Map();
     /** Saved SDK session IDs for resume after idle eviction */
     const savedSessionIds = new Map();
+    const conversationCache = new Map();
+    let conversationCacheLoadedAt = 0;
+    async function refreshConversationCache(force = false) {
+        if (!force && conversationCache.size > 0 && Date.now() - conversationCacheLoadedAt < 10_000) {
+            return;
+        }
+        const conversations = await client.getConversations();
+        conversationCache.clear();
+        for (const conversation of conversations) {
+            conversationCache.set(conversation.id, conversation);
+        }
+        conversationCacheLoadedAt = Date.now();
+    }
+    async function getConversationMeta(conversationId) {
+        try {
+            await refreshConversationCache();
+            const cached = conversationCache.get(conversationId);
+            if (cached)
+                return cached;
+            await refreshConversationCache(true);
+            return conversationCache.get(conversationId) ?? null;
+        }
+        catch {
+            return conversationCache.get(conversationId) ?? null;
+        }
+    }
+    async function loadParticipantContext(input) {
+        const [conversation, recentMessages] = await Promise.all([
+            getConversationMeta(input.conversationId),
+            client.getMessages(input.conversationId, 6).catch(() => []),
+        ]);
+        const recentSenderTypes = recentMessages
+            .filter((message) => message.senderId !== agentId)
+            .map((message) => message.senderType);
+        let consecutiveAgentTurns = 0;
+        for (const senderType of recentSenderTypes) {
+            if (senderType !== 'ai_agent')
+                break;
+            consecutiveAgentTurns += 1;
+        }
+        return {
+            conversationType: conversation?.type ?? 'unknown',
+            memberCount: conversation?.memberIds?.length ?? null,
+            senderType: input.message.senderType ?? 'human',
+            senderName: input.senderName,
+            isOwner: input.isOwner,
+            mentionedAgent: Array.isArray(input.message.mentions) && input.message.mentions.includes(agentId),
+            recentSenderTypes,
+            recentHumanCount: recentSenderTypes.filter((senderType) => senderType === 'human').length,
+            recentAgentCount: recentSenderTypes.filter((senderType) => senderType === 'ai_agent').length,
+            consecutiveAgentTurns,
+        };
+    }
     function closeSession(conversationId) {
         const session = sessions.get(conversationId);
         if (!session)
@@ -555,8 +780,13 @@ async function main() {
         }
         if (session.streamingTimer)
             clearTimeout(session.streamingTimer);
+        if (session.idleResetTimer) {
+            clearTimeout(session.idleResetTimer);
+            session.idleResetTimer = null;
+        }
         rtdbWrite(`/streaming/${conversationId}/${agentId}`, null).catch(() => { });
         clearSessionState(conversationId, agentId).catch(() => { });
+        clearTurnState(conversationId, agentId).catch(() => { });
         client.setTyping(conversationId, false).catch(() => { });
         try {
             session.query.close();
@@ -600,6 +830,7 @@ async function main() {
                     savedSessionIds.set(convoId, sdkSessionId);
                 sessions.delete(convoId);
                 clearSessionState(convoId, agentId).catch(() => { });
+                clearTurnState(convoId, agentId).catch(() => { });
             }, {
                 model: config?.model ?? runtimeModels[0]?.value,
                 permissionMode: config?.permissionMode ?? 'default',
@@ -641,22 +872,35 @@ async function main() {
                 const sender = m.senderName || m.senderId;
                 const content = renderInboundContent(m);
                 const isOwner = m.isOwner ?? (ownerId != null && m.senderId === ownerId);
-                console.error(`[canon-host] [${convoId.slice(0, 8)}] Message from ${sender}: "${content.slice(0, 80)}"`);
                 void (async () => {
+                    const participantContext = await loadParticipantContext({
+                        conversationId: convoId,
+                        message: m,
+                        senderName: sender,
+                        isOwner,
+                    });
+                    const autoReply = decideAutoReply(participantContext);
+                    if (!autoReply.allow) {
+                        console.error(`[canon-host] [${convoId.slice(0, 8)}] Suppressed auto-reply: ${autoReply.reason}`);
+                        return;
+                    }
+                    console.error(`[canon-host] [${convoId.slice(0, 8)}] Message from ${sender}: "${content.slice(0, 80)}" (${autoReply.reason})`);
                     const session = await getOrCreateSession(convoId);
-                    session.sendInput({
+                    const turnMetadata = normalizeTurnMetadata(m.metadata);
+                    const deliveryIntent = turnMetadata?.deliveryIntent ?? 'queue';
+                    const shouldMarkAccepted = turnMetadata?.inboundDisposition === 'queued';
+                    session.enqueueInbound({
                         type: 'user',
                         message: {
                             role: 'user',
                             content: buildCanonPrompt({
                                 content,
                                 conversationId: convoId,
-                                isOwner,
-                                senderName: sender,
+                                participantContext,
                             }),
                         },
                         parent_tool_use_id: null,
-                    });
+                    }, deliveryIntent, m.id ?? null, shouldMarkAccepted);
                 })();
             },
             onConnected: () => console.error('[canon-host] SSE connected'),
@@ -733,6 +977,17 @@ async function main() {
                             if (session && !session.closed) {
                                 console.error(`[canon-host] [${convoId.slice(0, 8)}] Interrupt signal`);
                                 try {
+                                    session.turnState = 'interrupted';
+                                    writeTurnState(convoId, agentId, {
+                                        turnId: session.currentTurnId,
+                                        state: 'interrupted',
+                                        queueDepth: session.pendingInputs.length,
+                                        currentSpeakerId: agentId,
+                                        lastAcceptedIntent: session.lastAcceptedIntent,
+                                        capabilities: CLAUDE_RUNTIME_CAPABILITIES,
+                                        ...(session.currentTurnOpenedAt ? { openedAt: session.currentTurnOpenedAt } : {}),
+                                        completedAt: { '.sv': 'timestamp' },
+                                    }).catch(() => { });
                                     await session.query.interrupt();
                                     if (session.streamingTimer) {
                                         clearTimeout(session.streamingTimer);
@@ -767,6 +1022,18 @@ async function main() {
                 hostMode: true,
                 isActive: true,
             }).catch(() => { });
+            writeTurnState(session.conversationId, agentId, {
+                turnId: session.currentTurnId,
+                state: session.turnState,
+                queueDepth: session.pendingInputs.length,
+                currentSpeakerId: agentId,
+                lastAcceptedIntent: session.lastAcceptedIntent,
+                capabilities: CLAUDE_RUNTIME_CAPABILITIES,
+                ...(session.currentTurnOpenedAt ? { openedAt: session.currentTurnOpenedAt } : {}),
+                ...(session.turnState === 'idle' || session.turnState === 'completed' || session.turnState === 'interrupted'
+                    ? { completedAt: { '.sv': 'timestamp' } }
+                    : {}),
+            }).catch(() => { });
         }
     }, HEARTBEAT_MS);
     // ── Idle session cleanup ──

package/dist/inbound-policy.d.ts

@@ -0,0 +1,19 @@
+import type { CanonConversation } from '@canonmsg/core';
+export interface InboundParticipantContext {
+    conversationType: CanonConversation['type'] | 'unknown';
+    memberCount: number | null;
+    senderType: 'human' | 'ai_agent';
+    senderName: string;
+    isOwner: boolean;
+    mentionedAgent: boolean;
+    recentSenderTypes: Array<'human' | 'ai_agent'>;
+    recentHumanCount: number;
+    recentAgentCount: number;
+    consecutiveAgentTurns: number;
+}
+export interface AutoReplyDecision {
+    allow: boolean;
+    reason: string;
+}
+export declare function buildInboundContextLines(context: InboundParticipantContext): string[];
+export declare function decideAutoReply(context: InboundParticipantContext): AutoReplyDecision;

package/dist/inbound-policy.js

@@ -0,0 +1,50 @@
+function formatRecentSenders(senderTypes) {
+    if (senderTypes.length === 0)
+        return 'none';
+    return senderTypes.map((senderType) => (senderType === 'ai_agent' ? 'agent' : 'human')).join(' -> ');
+}
+export function buildInboundContextLines(context) {
+    const conversationTypeLabel = context.conversationType === 'unknown'
+        ? 'unknown'
+        : `${context.conversationType}${context.memberCount ? ` (${context.memberCount} members)` : ''}`;
+    const senderRole = context.isOwner
+        ? 'The latest sender is the verified human owner of this Canon agent.'
+        : context.senderType === 'ai_agent'
+            ? 'The latest sender is another AI agent in Canon.'
+            : 'The latest sender is a human Canon participant.';
+    return [
+        senderRole,
+        `Latest sender name: ${context.senderName}`,
+        `Latest sender type: ${context.senderType}`,
+        `Conversation type: ${conversationTypeLabel}`,
+        `Directly addressed to this agent: ${context.mentionedAgent ? 'yes' : 'no'}`,
+        `Recent sender pattern: ${formatRecentSenders(context.recentSenderTypes)}`,
+        `Recent human messages: ${context.recentHumanCount}`,
+        `Recent agent messages: ${context.recentAgentCount}`,
+        `Consecutive recent agent turns: ${context.consecutiveAgentTurns}`,
+    ];
+}
+export function decideAutoReply(context) {
+    if (context.senderType !== 'ai_agent') {
+        return { allow: true, reason: 'latest sender is human' };
+    }
+    if (context.isOwner) {
+        return { allow: true, reason: 'owner messages always pass through' };
+    }
+    if (context.mentionedAgent) {
+        return { allow: true, reason: 'another agent explicitly addressed this agent' };
+    }
+    if (context.conversationType === 'group') {
+        return {
+            allow: false,
+            reason: 'suppressing group agent auto-reply without a direct mention',
+        };
+    }
+    if (context.consecutiveAgentTurns >= 2 && context.recentHumanCount === 0) {
+        return {
+            allow: false,
+            reason: 'suppressing likely agent-only loop in a direct conversation',
+        };
+    }
+    return { allow: true, reason: 'direct agent message allowed' };
+}

package/dist/server.js

@@ -28,6 +28,43 @@ let approvalServer = null;
 const conversationCache = new Map();
 /** The conversation that most recently triggered work (for approval routing) */
 let triggerConversationId = null;
+function getPrimaryAttachment(message) {
+    const attachment = message.attachments?.[0];
+    if (attachment?.url)
+        return attachment;
+    if (message.audioUrl) {
+        return {
+            kind: 'audio',
+            url: message.audioUrl,
+            durationMs: message.audioDurationMs,
+        };
+    }
+    if (message.imageUrl) {
+        return {
+            kind: 'image',
+            url: message.imageUrl,
+        };
+    }
+    return null;
+}
+function renderInboundContent(message) {
+    let content = message.text || '';
+    const attachment = getPrimaryAttachment(message);
+    if (attachment?.kind === 'audio') {
+        const duration = attachment.durationMs ? ` (${Math.round(attachment.durationMs / 1000)}s)` : '';
+        return content
+            ? `[Voice message${duration}: ${attachment.url}]\n${content}`
+            : `[Voice message${duration}: ${attachment.url}]`;
+    }
+    if (attachment?.kind === 'image') {
+        return content ? `[Image: ${attachment.url}]\n${content}` : `[Image: ${attachment.url}]`;
+    }
+    if (attachment?.kind === 'file') {
+        const label = attachment.fileName || 'File';
+        return content ? `[File: ${label} ${attachment.url}]\n${content}` : `[File: ${label} ${attachment.url}]`;
+    }
+    return content;
+}
 // ── Tool definitions ───────────────────────────────────────────────────
 server.setRequestHandler(ListToolsRequestSchema, async () => ({
     tools: [
@@ -51,7 +88,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
         },
         {
             name: 'send_message',
-            description: 'Send a message to a Canon conversation (supports text, images, audio)',
+            description: 'Send a message to a Canon conversation (supports text, images, audio, files)',
             inputSchema: {
                 type: 'object',
                 properties: {
@@ -65,7 +102,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
                     },
                     content_type: {
                         type: 'string',
-                        enum: ['text', 'image', 'audio'],
+                        enum: ['text', 'image', 'audio', 'file'],
                         description: 'Content type (default: text)',
                     },
                     image_url: {
@@ -76,8 +113,16 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
                         type: 'string',
                         description: 'Audio URL (when content_type is audio)',
                     },
+                    file_url: {
+                        type: 'string',
+                        description: 'File URL (when content_type is file)',
+                    },
+                    file_name: {
+                        type: 'string',
+                        description: 'Optional display filename for file attachments',
+                    },
                 },
-                required: ['conversation_id', 'text'],
+                required: ['conversation_id'],
             },
         },
         {
@@ -151,15 +196,34 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         }
         case 'send_message': {
             const conversationId = args.conversation_id;
-            const text = args.text;
+            const text = typeof args.text === 'string' ? args.text : '';
             const contentType = args.content_type || 'text';
-            const opts = {
-                contentType: contentType,
-            };
-            if (args.image_url)
-                opts.imageUrl = args.image_url;
-            if (args.audio_url)
-                opts.audioUrl = args.audio_url;
+            const opts = {};
+            const imageUrl = typeof args.image_url === 'string' ? args.image_url : null;
+            const audioUrl = typeof args.audio_url === 'string' ? args.audio_url : null;
+            const fileUrl = typeof args.file_url === 'string' ? args.file_url : null;
+            const fileName = typeof args.file_name === 'string' ? args.file_name : null;
+            if (contentType === 'image' && imageUrl) {
+                opts.contentType = 'image';
+                opts.attachments = [{ kind: 'image', url: imageUrl }];
+            }
+            else if (contentType === 'audio' && audioUrl) {
+                opts.contentType = 'audio';
+                opts.attachments = [{ kind: 'audio', url: audioUrl }];
+            }
+            else if (contentType === 'file' || fileUrl) {
+                opts.contentType = 'file';
+                if (fileUrl) {
+                    opts.attachments = [{
+                            kind: 'file',
+                            url: fileUrl,
+                            ...(fileName ? { fileName } : {}),
+                        }];
+                }
+            }
+            else {
+                opts.contentType = contentType;
+            }
             const result = await client.sendMessage(conversationId, text, opts);
             return {
                 content: [
@@ -261,16 +325,24 @@ async function handleInboundMessage(payload) {
         content_type: m.contentType || 'text',
         ts: new Date().toISOString(),
     };
+    const primaryAttachment = getPrimaryAttachment(m);
     if (m.imageUrl)
         meta.image_url = m.imageUrl;
     if (m.audioUrl)
         meta.audio_url = m.audioUrl;
-    console.error(`[canon] Inbound message from ${meta.sender_name}: "${m.text}"`);
+    if (primaryAttachment?.url) {
+        meta.attachment_kind = primaryAttachment.kind;
+        meta.attachment_url = primaryAttachment.url;
+    }
+    if (primaryAttachment?.fileName)
+        meta.attachment_file_name = primaryAttachment.fileName;
+    const renderedContent = renderInboundContent(m);
+    console.error(`[canon] Inbound message from ${meta.sender_name}: "${renderedContent}"`);
     try {
         await server.notification({
             method: 'notifications/claude/channel',
             params: {
-                content: m.text || '',
+                content: renderedContent,
                 meta,
             },
         });

package/dist/setup.d.ts

@@ -2,7 +2,7 @@
 /**
  * Setup script for the Canon Claude Code plugin.
  *
- * Run after `npm install -g @canon/claude-code-plugin` to:
+ * Run after `npm install -g @canonmsg/claude-code-plugin` to:
  * 1. Install the /canon-register and /canon-configure skills
  * 2. Show the user how to add the MCP server to their .mcp.json
  */

package/dist/setup.js

@@ -2,7 +2,7 @@
 /**
  * Setup script for the Canon Claude Code plugin.
  *
- * Run after `npm install -g @canon/claude-code-plugin` to:
+ * Run after `npm install -g @canonmsg/claude-code-plugin` to:
  * 1. Install the /canon-register and /canon-configure skills
  * 2. Show the user how to add the MCP server to their .mcp.json
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@canonmsg/claude-code-plugin",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "Canon channel plugin for Claude Code — messaging where AI agents are first-class citizens",
   "type": "module",
   "main": "dist/server.js",
@@ -16,13 +16,13 @@
     ".claude-plugin"
   ],
   "scripts": {
-    "build": "tsc",
+    "build": "node -e \"require('fs').rmSync('dist',{recursive:true,force:true})\" && tsc",
     "dev": "tsc --watch",
-    "prepublishOnly": "npm run build"
+    "prepack": "npm run build"
   },
   "dependencies": {
-    "@anthropic-ai/claude-agent-sdk": "^0.2.92",
-    "@canonmsg/core": "^0.2.2",
+    "@anthropic-ai/claude-agent-sdk": "^0.2.101",
+    "@canonmsg/core": "^0.3.0",
     "@modelcontextprotocol/sdk": "^1.12.0"
   },
   "engines": {

package/dist/agent-profiles.d.ts

@@ -1,21 +0,0 @@
-/**
- * Shared agent profile management — loading, locking, and resolution.
- * Used by both host.ts and server.ts.
- */
-export interface AgentProfile {
-    apiKey: string;
-    agentId: string;
-    agentName: string;
-    registeredAt: string;
-}
-export declare const CANON_DIR: string;
-export declare const AGENTS_PATH: string;
-export declare const LOCKS_DIR: string;
-export declare function loadProfiles(): Record<string, AgentProfile>;
-export declare function isProcessAlive(pid: number): boolean;
-export declare function isProfileLocked(profile: string): {
-    locked: boolean;
-    pid?: number;
-};
-export declare function acquireLock(profile: string): void;
-export declare function releaseLock(profile: string): void;

package/dist/agent-profiles.js

@@ -1,63 +0,0 @@
-/**
- * Shared agent profile management — loading, locking, and resolution.
- * Used by both host.ts and server.ts.
- */
-import { readFileSync, writeFileSync, unlinkSync, mkdirSync } from 'node:fs';
-import { join } from 'node:path';
-import { homedir } from 'node:os';
-// ── Paths ────────────────────────────────────────────────────────────
-export const CANON_DIR = join(homedir(), '.canon');
-export const AGENTS_PATH = join(CANON_DIR, 'agents.json');
-export const LOCKS_DIR = join(CANON_DIR, 'locks');
-// ── Profile loading ──────────────────────────────────────────────────
-export function loadProfiles() {
-    try {
-        return JSON.parse(readFileSync(AGENTS_PATH, 'utf-8'));
-    }
-    catch {
-        return {};
-    }
-}
-// ── Process locking ──────────────────────────────────────────────────
-export function isProcessAlive(pid) {
-    try {
-        process.kill(pid, 0);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-export function isProfileLocked(profile) {
-    const lockPath = join(LOCKS_DIR, `${profile}.lock`);
-    try {
-        const pid = parseInt(readFileSync(lockPath, 'utf-8').trim());
-        if (isProcessAlive(pid))
-            return { locked: true, pid };
-        // Stale lock — clean it up
-        try {
-            unlinkSync(lockPath);
-        }
-        catch { }
-    }
-    catch {
-        // No lock file
-    }
-    return { locked: false };
-}
-export function acquireLock(profile) {
-    mkdirSync(LOCKS_DIR, { recursive: true });
-    const lockPath = join(LOCKS_DIR, `${profile}.lock`);
-    const check = isProfileLocked(profile);
-    if (check.locked) {
-        throw new Error(`Agent "${profile}" is in use by another session (PID ${check.pid})`);
-    }
-    writeFileSync(lockPath, String(process.pid));
-}
-export function releaseLock(profile) {
-    const lockPath = join(LOCKS_DIR, `${profile}.lock`);
-    try {
-        unlinkSync(lockPath);
-    }
-    catch { }
-}

package/dist/rtdb-rest.d.ts

@@ -1,34 +0,0 @@
-/**
- * Lightweight RTDB REST helper for session state.
- *
- * Uses Firebase Realtime Database REST API to avoid adding firebase-admin
- * as a dependency to the MCP plugin. The custom token from /agents/auth-token
- * is exchanged for a Firebase ID token before use with RTDB REST.
- */
-import { type CanonClient } from '@canonapp/core';
-export interface SessionStatePayload {
-    model?: string;
-    permissionMode?: string;
-    effort?: string;
-    cwd?: string;
-    hostMode?: boolean;
-    isActive: boolean;
-    updatedAt: {
-        '.sv': 'timestamp';
-    };
-}
-/** Must be called once before any RTDB operations. */
-export declare function initRTDBAuth(client: CanonClient): void;
-/** Generic RTDB REST write (PUT). */
-export declare function rtdbWrite(path: string, data: unknown): Promise<void>;
-/** Generic RTDB REST read (GET). */
-export declare function rtdbRead(path: string): Promise<unknown>;
-/**
- * Write session state to RTDB via REST API.
- * Path: /session-state/{conversationId}/{agentId}
- */
-export declare function writeSessionState(conversationId: string, agentId: string, state: Omit<SessionStatePayload, 'updatedAt'>): Promise<void>;
-/**
- * Clear session state from RTDB (full overwrite with isActive: false).
- */
-export declare function clearSessionState(conversationId: string, agentId: string): Promise<void>;

package/dist/rtdb-rest.js

@@ -1,128 +0,0 @@
-/**
- * Lightweight RTDB REST helper for session state.
- *
- * Uses Firebase Realtime Database REST API to avoid adding firebase-admin
- * as a dependency to the MCP plugin. The custom token from /agents/auth-token
- * is exchanged for a Firebase ID token before use with RTDB REST.
- */
-import { DEFAULT_RTDB_URL, FIREBASE_WEB_API_KEY } from '@canonapp/core';
-const RTDB_BASE = process.env.CANON_RTDB_URL || DEFAULT_RTDB_URL;
-const FIREBASE_API_KEY = process.env.CANON_FIREBASE_API_KEY || FIREBASE_WEB_API_KEY;
-// ── Token management ──────────────────────────────────────────────────
-let cachedIdToken = null;
-let idTokenExpiresAt = 0;
-let tokenClient = null;
-/** Must be called once before any RTDB operations. */
-export function initRTDBAuth(client) {
-    tokenClient = client;
-}
-/**
- * Exchange a Firebase custom token for an ID token via the Identity Toolkit API.
- */
-async function exchangeCustomTokenForIdToken(customToken) {
-    const url = `https://identitytoolkit.googleapis.com/v1/accounts:signInWithCustomToken?key=${FIREBASE_API_KEY}`;
-    const res = await fetch(url, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ token: customToken, returnSecureToken: true }),
-    });
-    if (!res.ok) {
-        const text = await res.text();
-        throw new Error(`Token exchange failed (${res.status}): ${text}`);
-    }
-    const data = await res.json();
-    return { idToken: data.idToken, expiresIn: parseInt(data.expiresIn, 10) };
-}
-/** Get a valid ID token for RTDB REST, refreshing if expired or expiring soon. */
-async function getToken() {
-    // Refresh if missing, expired, or expiring within 5 minutes
-    if (!cachedIdToken || Date.now() > idTokenExpiresAt - 5 * 60 * 1000) {
-        if (!tokenClient)
-            return null;
-        try {
-            const auth = await tokenClient.getAuthToken();
-            const { idToken, expiresIn } = await exchangeCustomTokenForIdToken(auth.token);
-            cachedIdToken = idToken;
-            idTokenExpiresAt = Date.now() + expiresIn * 1000;
-        }
-        catch (err) {
-            console.error('[canon] RTDB token refresh failed:', err);
-            return cachedIdToken; // Return stale token as fallback
-        }
-    }
-    return cachedIdToken;
-}
-// ── RTDB operations ───────────────────────────────────────────────────
-/** Generic RTDB REST write (PUT). */
-export async function rtdbWrite(path, data) {
-    const token = await getToken();
-    if (!token)
-        return;
-    const url = `${RTDB_BASE}${path}.json?auth=${token}`;
-    const res = await fetch(url, {
-        method: 'PUT',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify(data),
-    });
-    if (!res.ok) {
-        const text = await res.text();
-        throw new Error(`RTDB write failed (${res.status}): ${text}`);
-    }
-}
-/** Generic RTDB REST read (GET). */
-export async function rtdbRead(path) {
-    const token = await getToken();
-    if (!token)
-        return null;
-    const url = `${RTDB_BASE}${path}.json?auth=${token}`;
-    const res = await fetch(url);
-    if (!res.ok)
-        return null;
-    return res.json();
-}
-/**
- * Write session state to RTDB via REST API.
- * Path: /session-state/{conversationId}/{agentId}
- */
-export async function writeSessionState(conversationId, agentId, state) {
-    const token = await getToken();
-    if (!token)
-        return;
-    const url = `${RTDB_BASE}/session-state/${conversationId}/${agentId}.json?auth=${token}`;
-    const body = {
-        ...state,
-        updatedAt: { '.sv': 'timestamp' },
-    };
-    const res = await fetch(url, {
-        method: 'PUT',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify(body),
-    });
-    if (!res.ok) {
-        const text = await res.text();
-        throw new Error(`RTDB write failed (${res.status}): ${text}`);
-    }
-}
-/**
- * Clear session state from RTDB (full overwrite with isActive: false).
- */
-export async function clearSessionState(conversationId, agentId) {
-    const token = await getToken();
-    if (!token)
-        return;
-    const url = `${RTDB_BASE}/session-state/${conversationId}/${agentId}.json?auth=${token}`;
-    const body = {
-        isActive: false,
-        updatedAt: { '.sv': 'timestamp' },
-    };
-    // Use PUT (not PATCH) to clear stale fields like model/cwd
-    const res = await fetch(url, {
-        method: 'PUT',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify(body),
-    });
-    if (!res.ok) {
-        const text = await res.text();
-        console.error(`[canon] RTDB clear failed (${res.status}): ${text}`);
-    }
-}