@canonmsg/claude-code-plugin 0.33.0 → 0.34.1

package/dist/mcp-args.d.ts

@@ -8,11 +8,13 @@ export type McpParseResult<T> = {
 type ContentType = 'text' | 'image' | 'audio' | 'video' | 'file';
 export interface ReplyArgs {
     conversationId: string;
+    sourceMessageId: string;
     text: string;
 }
 export declare function parseReplyArgs(value: unknown): McpParseResult<ReplyArgs>;
 export interface SendMessageArgs {
     conversationId: string;
+    sourceMessageId: string;
     text: string;
     contentType: ContentType;
     imageUrl?: string;
@@ -27,6 +29,7 @@ export interface SendMessageArgs {
 export declare function parseSendMessageArgs(value: unknown): McpParseResult<SendMessageArgs>;
 export interface SetTypingArgs {
     conversationId: string;
+    sourceMessageId: string;
     typing: boolean;
     status?: 'typing' | 'thinking';
 }

package/dist/mcp-args.js

@@ -42,6 +42,9 @@ export function parseReplyArgs(value) {
     const conversationId = requiredString(value, 'conversation_id', 256);
     if (!conversationId.ok)
         return conversationId;
+    const sourceMessageId = requiredString(value, 'source_message_id', 256);
+    if (!sourceMessageId.ok)
+        return sourceMessageId;
     const text = requiredString(value, 'text');
     if (!text.ok)
         return text;
@@ -49,6 +52,7 @@ export function parseReplyArgs(value) {
         ok: true,
         value: {
             conversationId: conversationId.value,
+            sourceMessageId: sourceMessageId.value,
             text: text.value,
         },
     };
@@ -59,6 +63,9 @@ export function parseSendMessageArgs(value) {
     const conversationId = requiredString(value, 'conversation_id', 256);
     if (!conversationId.ok)
         return conversationId;
+    const sourceMessageId = requiredString(value, 'source_message_id', 256);
+    if (!sourceMessageId.ok)
+        return sourceMessageId;
     const contentType = parseContentType(value.content_type);
     if (!contentType.ok)
         return contentType;
@@ -74,6 +81,7 @@ export function parseSendMessageArgs(value) {
         ok: true,
         value: {
             conversationId: conversationId.value,
+            sourceMessageId: sourceMessageId.value,
             text: optionalString(value, 'text') ?? '',
             contentType: contentType.value,
             ...(imageUrl ? { imageUrl } : {}),
@@ -93,6 +101,9 @@ export function parseSetTypingArgs(value) {
     const conversationId = requiredString(value, 'conversation_id', 256);
     if (!conversationId.ok)
         return conversationId;
+    const sourceMessageId = requiredString(value, 'source_message_id', 256);
+    if (!sourceMessageId.ok)
+        return sourceMessageId;
     if (typeof value.typing !== 'boolean') {
         return { ok: false, error: 'typing must be a boolean' };
     }
@@ -104,6 +115,7 @@ export function parseSetTypingArgs(value) {
         ok: true,
         value: {
             conversationId: conversationId.value,
+            sourceMessageId: sourceMessageId.value,
             typing: value.typing,
             ...(status ? { status } : {}),
         },

package/dist/register.js

@@ -21,6 +21,7 @@ REQUIRED
 
 FLAGS
   --profile <name>           Local profile name in ~/.canon/agents.json
+  --agent-id <id>            Reconnect this exact transferred agent identity
   --environment <id>        Canon environment ID (or CANON_ENVIRONMENT_ID; default: canon-prod-v1)
   --base-url <url>           Canon API base URL override
   --stream-url <url>         Canon stream URL override
@@ -32,6 +33,7 @@ FLAGS
 EXAMPLES
   canon-register --name "My Claude" --description "Claude Code agent" --phone "+15551234567"
   canon-register --name "Frontend" --description "React work" --phone "+15551234567" --profile frontend
+  canon-register --name "Sold Agent" --description "Existing agent" --phone "+15551234567" --agent-id <id>
 
 After approval, start it with CANON_AGENT=<profile> canon-claude --cwd /path/to/project.`;
 const OPTIONS = {

package/dist/server.js

@@ -16,7 +16,10 @@ import { ApprovalHttpServer } from './approval-server.js';
 import { renderClaudeInboundContent } from './canon-user-content.js';
 import { runCli } from '@canonmsg/core';
 import { parseReplyArgs, parseSendMessageArgs, parseSetTypingArgs, } from './mcp-args.js';
-import { canonVerbToolDefinitions, createCanonCommunicationBinding, executeCanonVerbTool, isCanonToolVerb, } from '@canonmsg/agent-tools';
+import { canonVerbToolDefinitions, createCanonCommunicationBinding, executeCanonVerbTool, isCanonToolVerb, isCommunicateReplacedVerb, } from '@canonmsg/agent-tools';
+import { isProactiveCommunicationEnabled } from './communication-policy.js';
+import { InboundReplyAuthority, InboundReplyAuthorityError, } from './inbound-reply-authority.js';
+import { AgentContextState } from './agent-context-state.js';
 const HELP = `canon-channel-server — Claude Code MCP channel server for Canon
 
 USAGE
@@ -31,13 +34,12 @@ phone-controlled local sessions, use canon-claude instead.`;
 // ── MCP server ─────────────────────────────────────────────────────────
 const server = new Server({ name: 'canon-channel', version: '0.1.0' }, {
     capabilities: {
-        tools: {},
+        tools: { listChanged: true },
         experimental: { 'claude/channel': {} },
     },
 });
 let client = null;
 let stream = null;
-let agentContext = null;
 let approvalManager = null;
 let approvalServer = null;
 let rtdb = null;
@@ -46,10 +48,32 @@ const TURN_COMPLETE_METADATA = {
     turnSemantics: 'turn_complete',
 };
 const communicationBinding = createCanonCommunicationBinding();
+const inboundReplyAuthority = new InboundReplyAuthority();
+const agentContextState = new AgentContextState(() => {
+    void server.sendToolListChanged().catch((error) => {
+        console.error(`[canon] Failed to refresh communication tools: ${error instanceof Error ? error.message : error}`);
+    });
+});
 /** Last owner-visible conversation to route approval cards into. */
 let approvalConversationId = null;
 /** Whether the message that most recently triggered work came from the owner. */
 let triggerIsOwner = true;
+const INBOUND_SOURCE_PROPERTY = {
+    type: 'string',
+    description: 'The source_message_id from the inbound Canon channel metadata',
+};
+function requireInboundSource(conversationId, sourceMessageId) {
+    if (typeof conversationId !== 'string'
+        || !conversationId
+        || typeof sourceMessageId !== 'string'
+        || !sourceMessageId) {
+        return null;
+    }
+    return { conversationId, sourceMessageId };
+}
+function replyAuthorityError() {
+    return toolArgumentError('This action must target the exact current inbound Canon message and may only reply once.');
+}
 function getPrimaryAttachment(message) {
     const attachment = message.attachments?.[0];
     if (attachment?.url)
@@ -66,119 +90,144 @@ function toolArgumentError(error) {
     };
 }
 // ── Tool definitions ───────────────────────────────────────────────────
-server.setRequestHandler(ListToolsRequestSchema, async () => ({
-    tools: [
-        {
-            name: 'reply',
-            description: 'Reply to a Canon conversation',
-            inputSchema: {
-                type: 'object',
-                properties: {
-                    conversation_id: {
-                        type: 'string',
-                        description: 'The conversation ID to reply to',
-                    },
-                    text: {
-                        type: 'string',
-                        description: 'Message text to send',
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+    await agentContextState.ready;
+    return {
+        tools: [
+            {
+                name: 'reply',
+                description: 'Reply to the current inbound Canon conversation',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        conversation_id: {
+                            type: 'string',
+                            description: 'The conversation ID to reply to',
+                        },
+                        source_message_id: INBOUND_SOURCE_PROPERTY,
+                        text: {
+                            type: 'string',
+                            description: 'Message text to send',
+                        },
                     },
+                    required: ['conversation_id', 'source_message_id', 'text'],
                 },
-                required: ['conversation_id', 'text'],
             },
-        },
-        {
-            name: 'send_message',
-            description: 'Send a message to a Canon conversation (supports text, images, audio, video, files)',
-            inputSchema: {
-                type: 'object',
-                properties: {
-                    conversation_id: {
-                        type: 'string',
-                        description: 'The conversation ID',
-                    },
-                    text: {
-                        type: 'string',
-                        description: 'Message text',
-                    },
-                    content_type: {
-                        type: 'string',
-                        enum: ['text', 'image', 'audio', 'video', 'file'],
-                        description: 'Content type (default: text)',
-                    },
-                    image_url: {
-                        type: 'string',
-                        description: 'Image URL (when content_type is image)',
-                    },
-                    audio_url: {
-                        type: 'string',
-                        description: 'Audio URL (when content_type is audio)',
-                    },
-                    video_url: {
-                        type: 'string',
-                        description: 'Video URL (when content_type is video)',
-                    },
-                    file_url: {
-                        type: 'string',
-                        description: 'File URL (when content_type is file)',
-                    },
-                    media_path: {
-                        type: 'string',
-                        description: 'Local image/audio/video/file path to upload and send',
-                    },
-                    file_name: {
-                        type: 'string',
-                        description: 'Optional display filename for file attachments',
-                    },
-                    mime_type: {
-                        type: 'string',
-                        description: 'Optional MIME type for media_path uploads',
-                    },
-                    duration_ms: {
-                        type: 'number',
-                        description: 'Optional audio duration in milliseconds for media_path uploads',
+            {
+                name: 'send_message',
+                description: 'Reply with text or media in the current inbound Canon conversation',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        conversation_id: {
+                            type: 'string',
+                            description: 'The conversation ID',
+                        },
+                        source_message_id: INBOUND_SOURCE_PROPERTY,
+                        text: {
+                            type: 'string',
+                            description: 'Message text',
+                        },
+                        content_type: {
+                            type: 'string',
+                            enum: ['text', 'image', 'audio', 'video', 'file'],
+                            description: 'Content type (default: text)',
+                        },
+                        image_url: {
+                            type: 'string',
+                            description: 'Image URL (when content_type is image)',
+                        },
+                        audio_url: {
+                            type: 'string',
+                            description: 'Audio URL (when content_type is audio)',
+                        },
+                        video_url: {
+                            type: 'string',
+                            description: 'Video URL (when content_type is video)',
+                        },
+                        file_url: {
+                            type: 'string',
+                            description: 'File URL (when content_type is file)',
+                        },
+                        media_path: {
+                            type: 'string',
+                            description: 'Local image/audio/video/file path to upload and send',
+                        },
+                        file_name: {
+                            type: 'string',
+                            description: 'Optional display filename for file attachments',
+                        },
+                        mime_type: {
+                            type: 'string',
+                            description: 'Optional MIME type for media_path uploads',
+                        },
+                        duration_ms: {
+                            type: 'number',
+                            description: 'Optional audio duration in milliseconds for media_path uploads',
+                        },
                     },
+                    required: ['conversation_id', 'source_message_id'],
                 },
-                required: ['conversation_id'],
             },
-        },
-        {
-            name: 'list_agents',
-            description: 'List registered Canon agent profiles and their lock status',
-            inputSchema: {
-                type: 'object',
-                properties: {},
+            {
+                name: 'list_agents',
+                description: 'List registered Canon agent profiles and their lock status',
+                inputSchema: {
+                    type: 'object',
+                    properties: {},
+                },
             },
-        },
-        {
-            name: 'set_typing',
-            description: 'Show or hide typing indicator in a Canon conversation',
-            inputSchema: {
-                type: 'object',
-                properties: {
-                    conversation_id: {
-                        type: 'string',
-                        description: 'The conversation ID',
-                    },
-                    typing: {
-                        type: 'boolean',
-                        description: 'Whether to show typing indicator',
-                    },
-                    status: {
-                        type: 'string',
-                        enum: ['typing', 'thinking'],
-                        description: 'Typing status (default: typing). Use "thinking" when processing/reasoning.',
+            {
+                name: 'set_typing',
+                description: 'Show or hide typing indicator in a Canon conversation',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        conversation_id: {
+                            type: 'string',
+                            description: 'The conversation ID',
+                        },
+                        source_message_id: INBOUND_SOURCE_PROPERTY,
+                        typing: {
+                            type: 'boolean',
+                            description: 'Whether to show typing indicator',
+                        },
+                        status: {
+                            type: 'string',
+                            enum: ['typing', 'thinking'],
+                            description: 'Typing status (default: typing). Use "thinking" when processing/reasoning.',
+                        },
                     },
+                    required: ['conversation_id', 'source_message_id', 'typing'],
                 },
-                required: ['conversation_id', 'typing'],
             },
-        },
-        // Canonical verbs — projections of canon.verbs.v1 (@canonmsg/agent-tools).
-        // Channel mode owns no turn, so `no_reply` is an ack-only no-op here: the
-        // standalone session has no final delivery for it to suppress.
-        ...canonVerbToolDefinitions(),
-        ...(agentContext?.outboundPolicy === 'closed' ? [] : communicationBinding.tools),
-    ],
-}));
+            // Canonical verbs — projections of canon.verbs.v1 (@canonmsg/agent-tools).
+            // Channel mode owns no turn, so `no_reply` is an ack-only no-op here: the
+            // standalone session has no final delivery for it to suppress.
+            ...canonVerbToolDefinitions({ compactCommunication: true }).map((tool) => ({
+                ...tool,
+                description: `${tool.description} Use source_message_id from the inbound Canon channel metadata.`,
+                inputSchema: {
+                    ...tool.inputSchema,
+                    properties: {
+                        ...(tool.inputSchema.properties ?? {}),
+                        source_message_id: INBOUND_SOURCE_PROPERTY,
+                    },
+                    required: [
+                        ...new Set([
+                            ...(tool.inputSchema.required ?? []),
+                            'conversationId',
+                            'source_message_id',
+                        ]),
+                    ],
+                },
+            })),
+            ...(isProactiveCommunicationEnabled(agentContextState.current?.outboundPolicy)
+                ? communicationBinding.tools
+                : []),
+        ],
+    };
+});
 // ── Tool handlers ──────────────────────────────────────────────────────
 server.setRequestHandler(CallToolRequestSchema, async (request) => {
     if (!client) {
@@ -193,10 +242,22 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             const parsed = parseReplyArgs(args);
             if (!parsed.ok)
                 return toolArgumentError(parsed.error);
-            const { conversationId, text } = parsed.value;
-            const result = await client.sendMessage(conversationId, text, {
-                metadata: TURN_COMPLETE_METADATA,
-            });
+            const { conversationId, sourceMessageId, text } = parsed.value;
+            let result;
+            try {
+                result = await inboundReplyAuthority.sendVisibleReply({ conversationId, sourceMessageId }, (replyAuthority) => client.sendMessage(conversationId, text, {
+                    metadata: {
+                        ...TURN_COMPLETE_METADATA,
+                        turnId: `claude-channel:${sourceMessageId}`,
+                    },
+                    ...(replyAuthority ? { replyAuthority } : {}),
+                }));
+            }
+            catch (error) {
+                if (error instanceof InboundReplyAuthorityError)
+                    return replyAuthorityError();
+                throw error;
+            }
             return {
                 content: [
                     {
@@ -210,25 +271,9 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             const parsed = parseSendMessageArgs(args);
             if (!parsed.ok)
                 return toolArgumentError(parsed.error);
-            const { conversationId, text, contentType, imageUrl, audioUrl, videoUrl, fileUrl, mediaPath, fileName, mimeType, durationMs, } = parsed.value;
+            const { conversationId, sourceMessageId, text, contentType, imageUrl, audioUrl, videoUrl, fileUrl, mediaPath, fileName, mimeType, durationMs, } = parsed.value;
             const opts = {};
             const metadata = TURN_COMPLETE_METADATA;
-            if (mediaPath) {
-                const result = await sendMediaFileMessage(client, conversationId, mediaPath, text, {
-                    ...(fileName ? { fileName } : {}),
-                    ...(mimeType ? { mimeType } : {}),
-                    ...(durationMs != null ? { durationMs } : {}),
-                    metadata,
-                });
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: `Message sent (${result.messageId})`,
-                        },
-                    ],
-                };
-            }
             if (contentType === 'image' && imageUrl) {
                 opts.contentType = 'image';
                 opts.attachments = [{ kind: 'image', url: imageUrl }];
@@ -269,7 +314,33 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 ...(opts.metadata ?? {}),
                 ...metadata,
             };
-            const result = await client.sendMessage(conversationId, text, opts);
+            let result;
+            try {
+                result = await inboundReplyAuthority.sendVisibleReply({ conversationId, sourceMessageId }, (replyAuthority) => mediaPath
+                    ? sendMediaFileMessage(client, conversationId, mediaPath, text, {
+                        ...(fileName ? { fileName } : {}),
+                        ...(mimeType ? { mimeType } : {}),
+                        ...(durationMs != null ? { durationMs } : {}),
+                        metadata: {
+                            ...metadata,
+                            turnId: `claude-channel:${sourceMessageId}`,
+                        },
+                        ...(replyAuthority ? { replyAuthority } : {}),
+                    })
+                    : client.sendMessage(conversationId, text, {
+                        ...opts,
+                        metadata: {
+                            ...metadata,
+                            turnId: `claude-channel:${sourceMessageId}`,
+                        },
+                        ...(replyAuthority ? { replyAuthority } : {}),
+                    }));
+            }
+            catch (error) {
+                if (error instanceof InboundReplyAuthorityError)
+                    return replyAuthorityError();
+                throw error;
+            }
             return {
                 content: [
                     {
@@ -303,7 +374,10 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             const parsed = parseSetTypingArgs(args);
             if (!parsed.ok)
                 return toolArgumentError(parsed.error);
-            const { conversationId, typing, status } = parsed.value;
+            const { conversationId, sourceMessageId, typing, status } = parsed.value;
+            if (!inboundReplyAuthority.validate({ conversationId, sourceMessageId })) {
+                return replyAuthorityError();
+            }
             await client.setTyping(conversationId, typing, status);
             return {
                 content: [
@@ -317,15 +391,34 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         default: {
             const name = request.params.name;
             if (communicationBinding.isToolName(name)) {
+                if (!isProactiveCommunicationEnabled(agentContextState.current?.outboundPolicy)) {
+                    return toolArgumentError('Outbound communication is not enabled by the agent operator.');
+                }
                 const result = await communicationBinding.execute(client, name, args);
                 return {
                     content: result.content.map((item) => ({ type: 'text', text: item.text })),
                     ...(result.isError ? { isError: true } : {}),
                 };
             }
-            if (isCanonToolVerb(name)) {
+            if (isCanonToolVerb(name) && !isCommunicateReplacedVerb(name)) {
                 const rawArgs = args && typeof args === 'object' ? { ...args } : {};
-                const verbResult = await executeCanonVerbTool(client, name, rawArgs);
+                const source = requireInboundSource(rawArgs.conversationId, rawArgs.source_message_id);
+                delete rawArgs.source_message_id;
+                if (!source)
+                    return replyAuthorityError();
+                if (name === 'no_reply') {
+                    if (!inboundReplyAuthority.consumeNoReply(source))
+                        return replyAuthorityError();
+                }
+                else if (!inboundReplyAuthority.validate(source)) {
+                    return replyAuthorityError();
+                }
+                const verbResult = await executeCanonVerbTool(client, name, rawArgs, {
+                    context: {
+                        conversationId: source.conversationId,
+                        sourceMessageId: source.sourceMessageId,
+                    },
+                });
                 return {
                     content: verbResult.content.map((item) => ({ type: 'text', text: item.text })),
                     ...(verbResult.isError ? { isError: true } : {}),
@@ -344,6 +437,11 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
 async function handleInboundMessage(payload) {
     const m = payload.message;
     const convo = conversationCache.get(payload.conversationId);
+    const pendingReplySource = inboundReplyAuthority.beginInbound({
+        conversationId: payload.conversationId,
+        sourceMessageId: m.id,
+        ...(payload.replyAuthority ? { replyAuthority: payload.replyAuthority } : {}),
+    });
     // Track turn provenance separately from the owner-visible approval route.
     // Non-owner direct chats do not include the owner, so approval cards still go
     // to the last owner conversation while the hook bypasses cached session rules.
@@ -362,9 +460,11 @@ async function handleInboundMessage(payload) {
             return;
         }
     }
+    inboundReplyAuthority.authorize(pendingReplySource);
     // meta must be Record<string, string> — non-string values cause silent drops
     const meta = {
         conversation_id: payload.conversationId,
+        source_message_id: m.id,
         sender_id: m.senderId,
         sender_name: m.senderName || m.senderId,
         sender_type: m.senderType || 'human',
@@ -406,7 +506,7 @@ async function handleInboundMessage(payload) {
                 id: m.id,
                 attachments: m.attachments ?? [],
             }, {
-                agentId: agentContext?.agentId ?? 'claude-code',
+                agentId: agentContextState.current?.agentId ?? 'claude-code',
                 conversationId: payload.conversationId,
             });
         }
@@ -449,6 +549,7 @@ async function handleInboundMessage(payload) {
         console.error('[canon] Notification sent to Claude Code');
     }
     catch (err) {
+        inboundReplyAuthority.revoke(pendingReplySource);
         const msg = err instanceof Error ? err.message : String(err);
         console.error(`[canon] Failed to send notification: ${msg}`);
     }
@@ -469,6 +570,7 @@ async function startChannel() {
         await verifyResolvedAgentEnvironment(resolvedRuntime);
     }
     catch (err) {
+        agentContextState.settleUnavailable();
         resolvedRuntime?.lockHandle?.release();
         console.error(err instanceof Error ? err.message : err);
         return;
@@ -480,18 +582,21 @@ async function startChannel() {
     // Get agent identity — try /agents/me first, fall back to /agents/auth-token
     let agentId;
     try {
-        agentContext = await client.getAgentMe();
-        agentId = agentContext.agentId;
-        console.error(`[canon] Connected as ${agentContext.displayName || agentId}`);
+        const context = await client.getAgentMe();
+        agentContextState.set(context);
+        agentId = context.agentId;
+        console.error(`[canon] Connected as ${context.displayName || agentId}`);
     }
     catch {
         // /agents/me may not be deployed — fall back to auth-token exchange
         try {
             const auth = await client.getAuthToken();
             agentId = auth.agentId;
+            agentContextState.settleUnavailable();
             console.error(`[canon] Authenticated as ${agentId}`);
         }
         catch (err) {
+            agentContextState.settleUnavailable();
             const msg = err instanceof Error ? err.message : String(err);
             console.error(`[canon] Failed to authenticate: ${msg}`);
             return;
@@ -513,7 +618,7 @@ async function startChannel() {
         runtime: 'claude-code',
         profile,
         agentId,
-        agentName: agentContext?.displayName ?? profileAgentName,
+        agentName: agentContextState.current?.displayName ?? profileAgentName,
         cwd: process.cwd(),
         launchCommand: ['canon-channel-server'],
         pid: process.pid,
@@ -546,7 +651,7 @@ async function startChannel() {
         handler: {
             onMessage: handleInboundMessage,
             onAgentContext: (ctx) => {
-                agentContext = ctx;
+                agentContextState.set(ctx);
             },
             onConnected: () => {
                 console.error('[canon] SSE stream connected');
@@ -564,8 +669,8 @@ async function startChannel() {
         console.error(`[canon] SSE start error: ${msg}`);
     });
     // Start approval system
-    if (agentContext?.ownerId) {
-        approvalManager = new ApprovalManager(client, agentId, agentContext.ownerId);
+    if (agentContextState.current?.ownerId) {
+        approvalManager = new ApprovalManager(client, agentId, agentContextState.current.ownerId);
         approvalServer = new ApprovalHttpServer(approvalManager, () => approvalConversationId, {
             token: process.env.CANON_CLAUDE_APPROVAL_TOKEN,
             getIsOwnerTurn: () => triggerIsOwner,
@@ -590,9 +695,9 @@ export async function main() {
     // Graceful shutdown — release agent lock and clear session state
     const shutdown = () => {
         // Mark all conversations as inactive
-        if (agentContext) {
+        if (agentContextState.current) {
             for (const convoId of conversationCache.keys()) {
-                rtdb?.clearSessionState(convoId, agentContext.agentId).catch(() => { });
+                rtdb?.clearSessionState(convoId, agentContextState.current.agentId).catch(() => { });
             }
         }
         approvalManager?.dispose();