@canonmsg/claude-code-plugin 0.15.0 → 0.15.2

package/dist/host.js

@@ -26,7 +26,7 @@ import { execFileSync } from 'node:child_process';
 import { existsSync } from 'node:fs';
 import { query, } from '@anthropic-ai/claude-agent-sdk';
 import { isAnthropicImageAttachment, materializeMessageMedia, materializeReplyContextMedia, toAnthropicImageBlock, } from '@canonmsg/agent-sdk';
-import { CLAUDE_EFFORT_OPTIONS, CLAUDE_PERMISSION_MODE_OPTIONS, RUNTIME_NEW_SESSION_ACTION, RUNTIME_STOP_ACTION, RUNTIME_STOP_AND_DROP_ACTION, buildCanonTurnContextV2, buildConfiguredWorkspaceOptionsWithRoots, buildConversationEnvironmentKey, buildFirstPartyCodingRuntimeDescriptor, buildHydratedInboundContext, diffCanonMemberIds, buildPlanApprovalRequest, buildQuestionRequest, buildPublicWorkspaceRoots, buildPublicWorkspaceOptions, buildRuntimePresentationPolicy, DEFAULT_FIRST_PARTY_RUNTIME_PRESENTATION, createConversationMetadataLoader, createTurnOutputController, createRuntimeStatePublisher, createTypingStatusPublisher, EXECUTION_ENVIRONMENT_MODES, CanonClient, CanonStream, DEFAULT_PARTICIPATION_HISTORY_FETCH_LIMIT, DEFAULT_RUNTIME_CAPABILITIES, HOST_ADMISSION_ACTIONS_DISABLED, ApprovalManager, ExecutionEnvironmentError, FINAL_MESSAGE_HANDOFF_MS, buildLocalRuntimeId, getActiveProfileLock, heartbeatLocalRuntimeEntry, normalizeTurnMetadata, prepareConversationEnvironment, resolveCanonAgent, initRTDBAuth, rtdbRead, rtdbWrite, sendMessageWithRetry, loadHostSessionConfig, loadRuntimeSessionState, markLocalRuntimeStopped, releaseConversationEnvironment, saveRuntimeSessionState, clearRuntimeSessionState, publishHostAgentRuntime, publishHostSessionSnapshots, renderCanonHostInboundContent, renderCanonTurnBriefPrompt, resolveHostWorkspaceCwd, upsertLocalRuntimeEntry, } from '@canonmsg/core';
+import { CLAUDE_EFFORT_OPTIONS, CLAUDE_PERMISSION_MODE_OPTIONS, RUNTIME_NEW_SESSION_ACTION, RUNTIME_STOP_ACTION, RUNTIME_STOP_AND_DROP_ACTION, buildCanonTurnContextV2, buildConfiguredWorkspaceOptionsWithRoots, buildConversationEnvironmentKey, buildFirstPartyCodingRuntimeDescriptor, buildHydratedInboundContext, diffCanonMemberIds, buildPlanApprovalRequest, buildPublicWorkspaceRoots, buildPublicWorkspaceOptions, buildRuntimePresentationPolicy, DEFAULT_FIRST_PARTY_RUNTIME_PRESENTATION, createConversationMetadataLoader, createTurnOutputController, createRuntimeStatePublisher, createTypingStatusPublisher, EXECUTION_ENVIRONMENT_MODES, CanonClient, CanonStream, DEFAULT_PARTICIPATION_HISTORY_FETCH_LIMIT, DEFAULT_RUNTIME_CAPABILITIES, HOST_ADMISSION_ACTIONS_DISABLED, ApprovalManager, ExecutionEnvironmentError, FINAL_MESSAGE_HANDOFF_MS, buildLocalRuntimeId, getActiveProfileLock, heartbeatLocalRuntimeEntry, normalizeTurnMetadata, prepareConversationEnvironment, resolveCanonAgent, initRTDBAuth, rtdbRead, rtdbWrite, sendMessageWithRetry, loadHostSessionConfig, loadRuntimeSessionState, markLocalRuntimeStopped, releaseConversationEnvironment, saveRuntimeSessionState, clearRuntimeSessionState, publishHostAgentRuntime, publishHostSessionSnapshots, renderCanonHostInboundContent, renderCanonTurnBriefPrompt, resolveHostWorkspaceCwd, upsertLocalRuntimeEntry, } from '@canonmsg/core';
 import { decideAutoReply, } from './inbound-policy.js';
 import { runCli } from './cli-entry.js';
 import { decideClaudeToolPermissionForMode, parseAllowedNonOwnerClaudeTools, } from './tool-policy.js';
@@ -87,21 +87,6 @@ let runtimeMetadata = {
 let runtimeMetadataRefresh = null;
 function buildClaudeRuntimeDescriptor(input) {
     const commands = [
-        {
-            id: 'plan',
-            label: 'Plan first',
-            description: 'Switch Claude into Plan mode. Text after /plan is kept as a ready prompt while the mode applies.',
-            aliases: ['plan'],
-            category: 'plan',
-            placements: ['composer_slash', 'command_palette'],
-            availability: ['always'],
-            trailingTextBehavior: 'send_as_prompt',
-            dispatch: {
-                kind: 'control',
-                controlId: 'permissionMode',
-                value: 'plan',
-            },
-        },
         {
             id: 'runtime-status',
             label: 'Runtime status',
@@ -190,6 +175,25 @@ function buildClaudeRuntimeDescriptor(input) {
         permissionModes: CLAUDE_PERMISSION_MODE_OPTIONS,
         defaultPermissionMode: 'default',
         streamingTextMode: 'delta',
+        turnModes: [
+            {
+                id: 'normal',
+                label: 'Normal',
+                description: 'Let Claude answer or act normally.',
+                scope: 'session',
+                default: true,
+                activation: { kind: 'control', controlId: 'permissionMode', value: 'default' },
+            },
+            {
+                id: 'plan',
+                label: 'Plan',
+                description: 'Switch Claude Code into Plan mode.',
+                scope: 'session',
+                ownerOnly: true,
+                aliases: ['plan'],
+                activation: { kind: 'control', controlId: 'permissionMode', value: 'plan' },
+            },
+        ],
         admissionActions: HOST_ADMISSION_ACTIONS_DISABLED,
         presentation: input.presentation,
         commands,
@@ -380,6 +384,71 @@ async function refreshClaudeRuntimeMetadata(input) {
     });
     return runtimeMetadataRefresh;
 }
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function mapClaudeQuestions(value) {
+    if (!Array.isArray(value))
+        return undefined;
+    const questions = value.slice(0, 12).flatMap((entry) => {
+        if (!entry || typeof entry !== 'object' || Array.isArray(entry))
+            return [];
+        const record = entry;
+        const id = typeof record.id === 'string' && record.id.trim()
+            ? record.id.trim().slice(0, 120)
+            : typeof record.question === 'string' && record.question.trim()
+                ? record.question.trim().slice(0, 80).replace(/[^A-Za-z0-9_.:-]+/g, '-')
+                : null;
+        const question = typeof record.question === 'string' && record.question.trim()
+            ? record.question.trim().slice(0, 1000)
+            : null;
+        if (!id || !/^[A-Za-z0-9_.:-]{1,120}$/.test(id) || !question)
+            return [];
+        const header = typeof record.header === 'string' && record.header.trim()
+            ? record.header.trim().slice(0, 120)
+            : undefined;
+        const rawOptions = Array.isArray(record.options) ? record.options : [];
+        const choices = rawOptions.slice(0, 12).flatMap((option) => {
+            if (!option || typeof option !== 'object' || Array.isArray(option))
+                return [];
+            const optionRecord = option;
+            const label = typeof optionRecord.label === 'string' && optionRecord.label.trim()
+                ? optionRecord.label.trim().slice(0, 120)
+                : typeof optionRecord.value === 'string' && optionRecord.value.trim()
+                    ? optionRecord.value.trim().slice(0, 120)
+                    : null;
+            if (!label)
+                return [];
+            const optionValue = typeof optionRecord.value === 'string' && optionRecord.value.trim()
+                ? optionRecord.value.trim().slice(0, 120)
+                : label;
+            return [{
+                    label,
+                    value: optionValue,
+                    ...(typeof optionRecord.description === 'string' && optionRecord.description.trim()
+                        ? { description: optionRecord.description.trim().slice(0, 240) }
+                        : {}),
+                }];
+        });
+        return [{
+                id,
+                question,
+                ...(header ? { header } : {}),
+                ...(choices.length ? { choices } : {}),
+                ...(record.isOther === true || record.allowOther === true ? { allowOther: true } : {}),
+                ...(record.isSecret === true ? { isSecret: true } : {}),
+                ...(record.multiSelect === true ? { multiSelect: true } : {}),
+            }];
+    });
+    return questions.length ? questions : undefined;
+}
+function flattenRuntimeInputAnswers(answers) {
+    const flattened = {};
+    for (const [questionId, answer] of Object.entries(answers ?? {})) {
+        flattened[questionId] = answer.answers.join(', ');
+    }
+    return flattened;
+}
 function mapClaudeMcpStatus(status) {
     switch (status) {
         case 'connected':
@@ -692,6 +761,30 @@ function createSession(conversationId, environment, agentId, client, typingSigna
             };
         });
     }
+    async function waitForRuntimeInputResponse(input) {
+        session.lastActivity = Date.now();
+        while (Date.now() < input.expiresAt) {
+            const response = await client.consumeRuntimeInputResponse({
+                conversationId,
+                inputId: input.inputId,
+            }).catch(() => null);
+            if (response?.status === 'submitted') {
+                return { status: 'submitted', answers: response.answers, value: response.value };
+            }
+            if (response?.status === 'cancelled' || response?.status === 'timeout') {
+                return { status: response.status };
+            }
+            await sleep(1_000);
+        }
+        const response = await client.consumeRuntimeInputResponse({
+            conversationId,
+            inputId: input.inputId,
+        }).catch(() => null);
+        if (response?.status === 'submitted') {
+            return { status: 'submitted', answers: response.answers, value: response.value };
+        }
+        return { status: 'timeout' };
+    }
     const claudeCliPath = resolveClaudeCliPath();
     const queryOptions = {
         systemPrompt: { type: 'preset', preset: 'claude_code' },
@@ -715,24 +808,43 @@ function createSession(conversationId, environment, agentId, client, typingSigna
             if (toolName === 'AskUserQuestion') {
                 try {
                     const questionId = randomUUID();
-                    const questions = input.questions ?? [];
-                    const questionCard = buildQuestionRequest(questionId, questions, cardResponseUser);
-                    await sendMessageWithRetry(client, conversationId, questionCard.text, {
-                        messageId: `claude-question-${questionId}`,
-                        ...(session.activeSelfContextId
-                            ? { selfContextId: session.activeSelfContextId }
-                            : {}),
-                        metadata: {
-                            ...questionCard.metadata,
-                            turnSemantics: 'control',
-                            replyBehavior: 'suppress_auto_reply',
+                    const questions = mapClaudeQuestions(input.questions);
+                    const expiresAt = Date.now() + REPLY_TIMEOUT_MS;
+                    await client.createRuntimeInputRequest({
+                        conversationId,
+                        inputId: questionId,
+                        kind: 'clarify',
+                        expiresAt,
+                        title: 'Claude needs input',
+                        prompt: questions?.length
+                            ? 'Claude needs your input to continue.'
+                            : 'Claude needs input to continue.',
+                        ...(questions ? { questions } : {}),
+                        sensitive: Boolean(questions?.some((question) => question.isSecret)),
+                        ...(cardResponseUserId ? { responseUserId: cardResponseUserId } : {}),
+                        native: {
+                            runtime: 'claude-code',
+                            method: 'AskUserQuestion',
+                            requestId: questionId,
+                            turnId: session.currentTurnId ?? undefined,
                         },
+                        turnId: session.currentTurnId ?? undefined,
                     });
-                    console.error(`[canon-host] [${conversationId.slice(0, 8)}] Question sent (${questionId.slice(0, 8)})`);
-                    const reply = await waitForReply('question_reply', questionId);
+                    console.error(`[canon-host] [${conversationId.slice(0, 8)}] Runtime input question sent (${questionId.slice(0, 8)})`);
+                    const reply = await waitForRuntimeInputResponse({ inputId: questionId, expiresAt });
+                    if (reply.status !== 'submitted') {
+                        return { behavior: 'deny', message: 'No reply received (timed out)' };
+                    }
                     return {
                         behavior: 'allow',
-                        updatedInput: { ...input, answers: reply.answers },
+                        updatedInput: {
+                            ...input,
+                            answers: reply.answers
+                                ? flattenRuntimeInputAnswers(reply.answers)
+                                : reply.value
+                                    ? { answer: reply.value }
+                                    : {},
+                        },
                     };
                 }
                 catch {
@@ -2184,6 +2296,10 @@ export async function main() {
                 }
                 const sender = m.senderName || m.senderId;
                 const isOwner = m.isOwner ?? (ownerId != null && m.senderId === ownerId);
+                if (payload.turnDispatch && payload.turnDispatch.kind !== 'run_turn') {
+                    console.error(`[canon-host] [${convoId.slice(0, 8)}] Ignoring server-dispatched observe-only message: ${payload.turnDispatch.reason}`);
+                    return;
+                }
                 void (async () => {
                     let materialized = [];
                     if (m.id) {
@@ -2218,7 +2334,12 @@ export async function main() {
                     });
                     const replyContext = replyMedia.replyContext;
                     const participantContext = hydrated.participantContext;
-                    const autoReply = decideAutoReply(participantContext, behavior);
+                    const autoReply = payload.turnDispatch?.kind === 'run_turn'
+                        ? {
+                            allow: true,
+                            reason: payload.turnDispatch.reason || 'server dispatch allowed this turn',
+                        }
+                        : decideAutoReply(participantContext, behavior);
                     if (!autoReply.allow) {
                         console.error(`[canon-host] [${convoId.slice(0, 8)}] Suppressed auto-reply: ${autoReply.reason}`);
                         return;

package/dist/mcp-args.d.ts

@@ -1,4 +1,4 @@
-import type { SendContextualMessageOptions } from '@canonmsg/core';
+import type { DirectSessionSelection, SendContextualMessageOptions } from '@canonmsg/core';
 export type McpParseResult<T> = {
     ok: true;
     value: T;
@@ -32,6 +32,7 @@ export interface SendContextualMessageArgs {
     targetUserId?: string;
     text: string;
     selfContext: SendContextualMessageOptions['selfContext'];
+    sessionSelection?: DirectSessionSelection;
     messageOptions?: SendContextualMessageOptions['messageOptions'];
 }
 export declare function parseSendContextualMessageArgs(value: unknown): McpParseResult<SendContextualMessageArgs>;

package/dist/mcp-args.js

@@ -87,6 +87,28 @@ export function parseSendMessageArgs(value) {
         },
     };
 }
+function parseSessionSelection(value) {
+    if (value == null)
+        return { ok: true, value: undefined };
+    const raw = typeof value === 'string'
+        ? value
+        : isRecord(value) && typeof value.mode === 'string'
+            ? value.mode
+            : null;
+    const mode = raw?.trim().toLowerCase().replace(/-/g, '_');
+    if (!mode)
+        return { ok: false, error: 'Invalid session_selection' };
+    if (mode === 'new' || mode === 'fresh' || mode === 'start_new') {
+        return { ok: true, value: { mode: 'new' } };
+    }
+    if (mode === 'continue_latest' || mode === 'latest' || mode === 'continue') {
+        return { ok: true, value: { mode: 'continue_latest' } };
+    }
+    if (mode === 'continue_or_create' || mode === 'auto' || mode === 'reuse_or_create') {
+        return { ok: true, value: { mode: 'continue_or_create' } };
+    }
+    return { ok: false, error: 'session_selection must be new, continue_latest, or continue_or_create' };
+}
 export function parseSendContextualMessageArgs(value) {
     if (!isRecord(value))
         return { ok: false, error: 'Arguments must be an object' };
@@ -111,6 +133,9 @@ export function parseSendContextualMessageArgs(value) {
     if (type !== 'cross_session') {
         return { ok: false, error: 'self_context.type must be cross_session' };
     }
+    const sessionSelection = parseSessionSelection(value.session_selection);
+    if (!sessionSelection.ok)
+        return sessionSelection;
     const messageOptions = isRecord(value.message_options)
         ? value.message_options
         : undefined;
@@ -125,6 +150,7 @@ export function parseSendContextualMessageArgs(value) {
                 type: 'cross_session',
                 context: context.value,
             },
+            ...(sessionSelection.value ? { sessionSelection: sessionSelection.value } : {}),
             ...(messageOptions ? { messageOptions } : {}),
         },
     };

package/dist/server.js

@@ -163,6 +163,11 @@ server.setRequestHandler(ListToolsRequestSchema, async () => ({
                         type: 'object',
                         description: 'Required { type: "cross_session", context: "why I am saying this here" }',
                     },
+                    session_selection: {
+                        type: 'string',
+                        enum: ['new', 'continue_latest', 'continue_or_create'],
+                        description: 'Optional direct-agent session behavior when target_user_id is used',
+                    },
                     message_options: {
                         type: 'object',
                         description: 'Optional Canon send options for the contextual outbound message',
@@ -321,7 +326,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             const parsed = parseSendContextualMessageArgs(args);
             if (!parsed.ok)
                 return toolArgumentError(parsed.error);
-            const { sourceConversationId, targetConversationId, targetUserId, text, selfContext, messageOptions, } = parsed.value;
+            const { sourceConversationId, targetConversationId, targetUserId, text, selfContext, sessionSelection, messageOptions, } = parsed.value;
             const contextualMessageOptions = messageOptions;
             const result = await client.sendContextualMessage({
                 sourceConversationId,
@@ -329,6 +334,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 ...(targetUserId ? { targetUserId } : {}),
                 text,
                 selfContext,
+                ...(sessionSelection ? { sessionSelection } : {}),
                 ...(contextualMessageOptions
                     ? {
                         messageOptions: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@canonmsg/claude-code-plugin",
-  "version": "0.15.0",
+  "version": "0.15.2",
   "description": "Canon channel plugin for Claude Code — messaging where AI agents are first-class citizens",
   "type": "module",
   "main": "dist/index.js",
@@ -31,8 +31,8 @@
   },
   "dependencies": {
     "@anthropic-ai/claude-agent-sdk": "^0.2.141",
-    "@canonmsg/agent-sdk": "^3.0.0",
-    "@canonmsg/core": "^2.0.0",
+    "@canonmsg/agent-sdk": "^3.1.1",
+    "@canonmsg/core": "^2.1.1",
     "@modelcontextprotocol/sdk": "^1.29.0"
   },
   "engines": {