@canonmsg/codex-plugin 0.12.0 → 0.13.1

package/dist/host.js

@@ -5,7 +5,7 @@ import { spawnSync } from 'node:child_process';
 import { dirname } from 'node:path';
 import { parseArgs } from 'node:util';
 import { getCodexImagePath, materializeMessageMedia, materializeReplyContextMedia, } from '@canonmsg/agent-sdk';
-import { RUNTIME_NEW_SESSION_ACTION, RUNTIME_STOP_ACTION, RUNTIME_STOP_AND_DROP_ACTION, buildPlanApprovalRequest, buildCanonHostPrompt, buildConfiguredWorkspaceOptionsWithRoots, buildFirstPartyCodingRuntimeDescriptor, buildHydratedInboundContext, diffCanonMemberIds, buildPublicWorkspaceRoots, buildPublicWorkspaceOptions, buildRuntimePresentationPolicy, DEFAULT_FIRST_PARTY_RUNTIME_PRESENTATION, createConversationMetadataLoader, createRuntimeStatePublisher, EXECUTION_ENVIRONMENT_MODES, ExecutionEnvironmentError, CanonClient, CanonStream, DEFAULT_PARTICIPATION_HISTORY_FETCH_LIMIT, DEFAULT_RUNTIME_CAPABILITIES, FINAL_MESSAGE_HANDOFF_MS, getActiveProfileLock, initRTDBAuth, buildLocalRuntimeId, heartbeatLocalRuntimeEntry, loadRuntimeSessionState, markLocalRuntimeStopped, normalizeTurnMetadata, prepareConversationEnvironment, loadHostSessionConfig, releaseConversationEnvironment, resolveCanonAgent, rtdbRead, rtdbWrite, shouldTriggerAgentTurn, saveRuntimeSessionState, buildBoundedTurnTrail, publishHostAgentRuntime, publishHostSessionSnapshots, renderCanonHostInboundContent, resolveHostWorkspaceCwd, upsertLocalRuntimeEntry, } from '@canonmsg/core';
+import { RUNTIME_NEW_SESSION_ACTION, RUNTIME_STOP_ACTION, RUNTIME_STOP_AND_DROP_ACTION, buildRuntimeCardOutcome, buildPlanApprovalRequest, buildCanonHostPrompt, buildConfiguredWorkspaceOptionsWithRoots, buildFirstPartyCodingRuntimeDescriptor, buildHydratedInboundContext, diffCanonMemberIds, buildPublicWorkspaceRoots, buildPublicWorkspaceOptions, buildRuntimePresentationPolicy, DEFAULT_FIRST_PARTY_RUNTIME_PRESENTATION, createConversationMetadataLoader, createRuntimeStatePublisher, createTypingStatusPublisher, EXECUTION_ENVIRONMENT_MODES, ExecutionEnvironmentError, CanonClient, CanonStream, DEFAULT_PARTICIPATION_HISTORY_FETCH_LIMIT, DEFAULT_RUNTIME_CAPABILITIES, FINAL_MESSAGE_HANDOFF_MS, getActiveProfileLock, initRTDBAuth, buildLocalRuntimeId, heartbeatLocalRuntimeEntry, loadRuntimeSessionState, markLocalRuntimeStopped, normalizeTurnMetadata, parseRuntimeCardV1, prepareConversationEnvironment, loadHostSessionConfig, releaseConversationEnvironment, resolveCanonAgent, rtdbRead, rtdbWrite, sendMessageWithRetry, shouldTriggerAgentTurn, saveRuntimeSessionState, buildBoundedTurnTrail, publishHostAgentRuntime, publishHostSessionSnapshots, renderCanonHostInboundContent, resolveHostWorkspaceCwd, upsertLocalRuntimeEntry, } from '@canonmsg/core';
 import { buildInboundContextLines, decideAutoReply, } from './inbound-policy.js';
 import { CodexConversationAdapter, } from './adapter.js';
 import { CodexAppServerAdapter } from './app-server-adapter.js';
@@ -54,6 +54,8 @@ const IDLE_TIMEOUT_MS = 30 * 60 * 1000;
 const HEARTBEAT_MS = 30_000;
 const IDLE_CHECK_MS = 60_000;
 const CONTROL_POLL_MS = 2_000;
+const IDLE_CONTROL_POLL_MS = 10_000;
+const CONTROL_POLL_JITTER_MS = 1_000;
 const CODEX_RUNTIME_CAPABILITIES = {
     ...DEFAULT_RUNTIME_CAPABILITIES,
     supportsInterrupt: true,
@@ -61,6 +63,10 @@ const CODEX_RUNTIME_CAPABILITIES = {
     supportsQueue: true,
     supportsNonFinalPermanentMessages: false,
 };
+function controlPollDelayMs(hasActiveWork) {
+    const base = hasActiveWork ? CONTROL_POLL_MS : IDLE_CONTROL_POLL_MS;
+    return base + Math.floor(Math.random() * CONTROL_POLL_JITTER_MS);
+}
 let workingDir = process.cwd();
 let workspaceOptions = [];
 let workspaceRoots = [];
@@ -109,6 +115,21 @@ function buildCodexRuntimeDescriptor(input) {
         presentation: input.presentation,
         streamingTextMode: 'snapshot',
         commands,
+        ...(input.supportsRichCards
+            ? {
+                runtimeCards: {
+                    rich: {
+                        schema: 'canon.card.v1',
+                        lifecycle: 'blocking_requires_action',
+                        responder: 'agent_owner',
+                        result: 'action_or_values',
+                        maxTimeoutMs: 30 * 60_000,
+                        blockKinds: ['summary', 'metricGrid', 'chart', 'table', 'list', 'callout', 'actions'],
+                        native: true,
+                    },
+                },
+            }
+            : {}),
     });
     if (input.models.length > 0) {
         return descriptor;
@@ -375,6 +396,11 @@ export async function main() {
     console.error(`[canon-codex] Starting${profile ? ` (profile: ${profile})` : ''} in ${workingDir}`);
     const client = new CanonClient(apiKey, baseUrl);
     initRTDBAuth(client);
+    const typingSignals = createTypingStatusPublisher({
+        setTyping: (conversationId, typing, status) => status
+            ? client.setTyping(conversationId, typing, status)
+            : client.setTyping(conversationId, typing),
+    });
     let agentId;
     let ownerId = null;
     let ownerName = null;
@@ -645,31 +671,33 @@ export async function main() {
             turnId: session.currentTurnId ?? block.turnId,
         })));
     }
+    function buildCodexMessageId(session, kind) {
+        return `codex-${kind}-${session.currentTurnId ?? randomUUID()}`;
+    }
+    function buildCodexRuntimeCardOutcomeMessageId(cardId, status) {
+        return `codex-card-${cardId}-${status}`;
+    }
     async function handoffFinalMessage(conversationId) {
         await sleep(FINAL_MESSAGE_HANDOFF_MS);
         clearStreaming(conversationId);
-        client.setTyping(conversationId, false).catch(() => { });
+        typingSignals.clear(conversationId).catch(() => { });
     }
     function refreshVisibleWorkSignal(session) {
         if (!session.running || session.closed)
             return;
         if (session.turnState !== 'thinking' && session.turnState !== 'tool')
             return;
-        client.setTyping(session.conversationId, true, 'thinking').catch(() => { });
+        typingSignals.start(session.conversationId, 'thinking').catch(() => { });
     }
     function startVisibleWorkSignal(session) {
         refreshVisibleWorkSignal(session);
-        if (session.typingKeepaliveTimer)
-            return;
-        session.typingKeepaliveTimer = setInterval(() => {
-            refreshVisibleWorkSignal(session);
-        }, 3500);
     }
     function stopVisibleWorkSignal(session) {
         if (session.typingKeepaliveTimer) {
             clearInterval(session.typingKeepaliveTimer);
             session.typingKeepaliveTimer = null;
         }
+        typingSignals.clear(session.conversationId).catch(() => { });
     }
     function closeSession(conversationId) {
         const session = sessions.get(conversationId);
@@ -684,7 +712,8 @@ export async function main() {
         clearStreaming(conversationId);
         runtimeState.clearSessionState(conversationId).catch(() => { });
         runtimeState.clearTurnState(conversationId).catch(() => { });
-        client.setTyping(conversationId, false).catch(() => { });
+        typingSignals.clear(conversationId).catch(() => { });
+        typingSignals.dispose(conversationId);
         sessions.delete(conversationId);
     }
     async function resetRuntimeSession(session) {
@@ -710,7 +739,7 @@ export async function main() {
         }
         stopVisibleWorkSignal(session);
         clearStreaming(conversationId);
-        client.setTyping(conversationId, false).catch(() => { });
+        typingSignals.clear(conversationId).catch(() => { });
         writeState(session);
         writeTurn(session);
     }
@@ -893,10 +922,143 @@ export async function main() {
         }).catch(() => null);
         return { decision: 'deny' };
     }
+    async function waitForRuntimeCardResponse(input) {
+        while (Date.now() < input.expiresAt) {
+            const response = await client.consumeRuntimeCardResponse({
+                conversationId: input.conversationId,
+                cardId: input.cardId,
+            }).catch(() => null);
+            if (response?.status === 'submitted') {
+                return {
+                    status: 'submitted',
+                    ...(response.actionId ? { actionId: response.actionId } : {}),
+                    ...(response.values ? { values: response.values } : {}),
+                };
+            }
+            if (response?.status === 'cancelled' || response?.status === 'timeout') {
+                return { status: response.status };
+            }
+            await sleep(1_000);
+        }
+        const response = await client.consumeRuntimeCardResponse({
+            conversationId: input.conversationId,
+            cardId: input.cardId,
+        }).catch(() => null);
+        if (response?.status === 'submitted') {
+            return {
+                status: 'submitted',
+                ...(response.actionId ? { actionId: response.actionId } : {}),
+                ...(response.values ? { values: response.values } : {}),
+            };
+        }
+        return { status: 'timeout' };
+    }
+    function runtimeCardRequestPayload(method, params) {
+        if (method !== 'item/runtimeCard/request'
+            && method !== 'runtimeCard/request') {
+            return null;
+        }
+        const input = isRecord(params.input) ? params.input : null;
+        const args = isRecord(params.arguments) ? params.arguments : null;
+        return params.card ?? params.cardDocument ?? input?.card ?? args?.card ?? null;
+    }
     async function handleCodexServerRequest(session, request) {
         const requestId = String(request.id);
         const params = request.params;
         const expiresAt = Date.now() + 30 * 60_000;
+        const runtimeCardPayload = runtimeCardRequestPayload(request.method, params);
+        if (runtimeCardPayload) {
+            const card = parseRuntimeCardV1(runtimeCardPayload);
+            if (!card) {
+                return { status: 'cancelled', error: 'Invalid canon.card.v1 card' };
+            }
+            const cardId = readString(params, 'cardId')
+                ?? readString(params, 'itemId')
+                ?? card.cardId
+                ?? requestId;
+            let requestCreated = false;
+            let requestResolved = false;
+            try {
+                await client.createRuntimeCardRequest({
+                    conversationId: session.conversationId,
+                    cardId,
+                    card: { ...card, cardId },
+                    expiresAt,
+                    // Omit responseUserId so the backend targets a reachable member (the
+                    // owner if present, else the sole other member) — the owner is often
+                    // not a member of agent-to-user DMs.
+                    native: {
+                        runtime: 'codex',
+                        method: request.method,
+                        requestId,
+                        turnId: readString(params, 'turnId') ?? session.currentTurnId ?? undefined,
+                        handles: {
+                            itemId: readString(params, 'itemId') ?? '',
+                            threadId: readString(params, 'threadId') ?? '',
+                        },
+                    },
+                    turnId: session.currentTurnId ?? undefined,
+                });
+                requestCreated = true;
+                session.turnState = 'waiting_input';
+                markTurnProgress(session);
+                upsertTurnBlock(session, {
+                    id: `card:${cardId}`,
+                    kind: 'input',
+                    status: 'pending',
+                    title: card.title,
+                    summary: card.template ?? 'runtime card',
+                });
+                writeTurn(session);
+                stopVisibleWorkSignal(session);
+                writeCodexStreaming(session, null, 'waiting_input');
+                const response = await waitForRuntimeCardResponse({
+                    conversationId: session.conversationId,
+                    cardId,
+                    expiresAt,
+                });
+                requestResolved = true;
+                const outcome = buildRuntimeCardOutcome(cardId, response.status, { reason: response.status });
+                await sendMessageWithRetry(client, session.conversationId, outcome.text, {
+                    messageId: buildCodexRuntimeCardOutcomeMessageId(cardId, response.status),
+                    metadata: {
+                        ...outcome.metadata,
+                        turnId: session.currentTurnId ?? undefined,
+                        turnSemantics: 'control',
+                        replyBehavior: 'suppress_auto_reply',
+                    },
+                });
+                completeTurnBlock(session, `card:${cardId}`, `Card ${response.status}`);
+                if (session.turnState === 'waiting_input') {
+                    session.turnState = 'thinking';
+                    markTurnProgress(session);
+                    writeTurn(session);
+                    startVisibleWorkSignal(session);
+                    writeCodexStreaming(session, null, 'thinking');
+                }
+                return response;
+            }
+            catch (error) {
+                if (requestCreated && !requestResolved) {
+                    await client.consumeRuntimeCardResponse({
+                        conversationId: session.conversationId,
+                        cardId,
+                        cancel: true,
+                    }).catch(() => null);
+                    const outcome = buildRuntimeCardOutcome(cardId, 'cancelled', { reason: 'interrupted' });
+                    await sendMessageWithRetry(client, session.conversationId, outcome.text, {
+                        messageId: buildCodexRuntimeCardOutcomeMessageId(cardId, 'cancelled'),
+                        metadata: {
+                            ...outcome.metadata,
+                            turnId: session.currentTurnId ?? undefined,
+                            turnSemantics: 'control',
+                            replyBehavior: 'suppress_auto_reply',
+                        },
+                    }).catch(() => null);
+                }
+                throw error;
+            }
+        }
         if (request.method === 'item/tool/requestUserInput') {
             const paramsInput = isRecord(params.input) ? params.input : null;
             const paramsArguments = isRecord(params.arguments) ? params.arguments : null;
@@ -1051,7 +1213,8 @@ export async function main() {
             const userMessage = error instanceof ExecutionEnvironmentError ? error.userMessage : message;
             console.error(`[canon-codex] [${input.conversationId.slice(0, 8)}] Failed to create session: ${message}`);
             await markQueuedMessageAccepted(input.conversationId, input.message.id, shouldMarkAccepted);
-            await client.sendMessage(input.conversationId, `I couldn't start a coding session for this workspace: ${userMessage}`, {
+            await sendMessageWithRetry(client, input.conversationId, `I couldn't start a coding session for this workspace: ${userMessage}`, {
+                messageId: `codex-start-failed-${input.message.id}`,
                 ...(activeSelfContextId ? { selfContextId: activeSelfContextId } : {}),
                 metadata: {
                     turnSemantics: 'turn_complete',
@@ -1074,7 +1237,7 @@ export async function main() {
             console.error(`[canon-codex] [${input.conversationId.slice(0, 8)}] Interrupting current turn for explicit human send-now`);
             await session.adapter.interrupt().catch(() => { });
             clearStreaming(input.conversationId);
-            client.setTyping(input.conversationId, false).catch(() => { });
+            typingSignals.clear(input.conversationId).catch(() => { });
             return;
         }
         enqueuePrompt(session, prompt, deliveryIntent, false, input.message.id, shouldMarkAccepted, imagePaths, mediaAddDirs, planCommand.planMode);
@@ -1123,7 +1286,6 @@ export async function main() {
                     markTurnProgress(session);
                     writeTurn(session);
                     stopVisibleWorkSignal(session);
-                    client.setTyping(session.conversationId, false).catch(() => { });
                     writeCodexStreaming(session, event.text, 'streaming');
                     return;
                 }
@@ -1132,7 +1294,6 @@ export async function main() {
                     markTurnProgress(session);
                     writeTurn(session);
                     stopVisibleWorkSignal(session);
-                    client.setTyping(session.conversationId, false).catch(() => { });
                     upsertTurnBlock(session, {
                         id: `plan:${session.currentTurnId}`,
                         kind: 'plan',
@@ -1211,7 +1372,8 @@ export async function main() {
                     title: 'Codex Plan',
                     body: result.finalMessage,
                 });
-                await client.sendMessage(session.conversationId, planApproval.text, {
+                await sendMessageWithRetry(client, session.conversationId, planApproval.text, {
+                    messageId: buildCodexMessageId(session, 'plan'),
                     metadata: {
                         ...planApproval.metadata,
                         turnId: session.currentTurnId,
@@ -1227,7 +1389,8 @@ export async function main() {
                     clearStoredThread();
                 }
                 const turnTrail = buildFinalTurnTrail(session);
-                await client.sendMessage(session.conversationId, result.finalMessage, {
+                await sendMessageWithRetry(client, session.conversationId, result.finalMessage, {
+                    messageId: buildCodexMessageId(session, 'final'),
                     ...(session.activeSelfContextId
                         ? { selfContextId: session.activeSelfContextId }
                         : {}),
@@ -1249,7 +1412,8 @@ export async function main() {
                     console.error(`[canon-codex] [${session.conversationId.slice(0, 8)}] Turn exited ${result.exitCode}: ${result.errorText}`);
                 }
                 const turnTrail = buildFinalTurnTrail(session);
-                await client.sendMessage(session.conversationId, userVisibleError, {
+                await sendMessageWithRetry(client, session.conversationId, userVisibleError, {
+                    messageId: buildCodexMessageId(session, 'error'),
                     ...(session.activeSelfContextId
                         ? { selfContextId: session.activeSelfContextId }
                         : {}),
@@ -1270,7 +1434,7 @@ export async function main() {
                 writeTurn(session);
                 stopVisibleWorkSignal(session);
                 clearStreaming(session.conversationId);
-                client.setTyping(session.conversationId, false).catch(() => { });
+                typingSignals.clear(session.conversationId).catch(() => { });
                 console.error(`[canon-codex] [${session.conversationId.slice(0, 8)}] Turn interrupted`);
             }
         }
@@ -1280,7 +1444,8 @@ export async function main() {
                 : `The Codex host failed to start a turn: ${error instanceof Error ? error.message : String(error)}`;
             session.state.lastError = message;
             writeState(session);
-            await client.sendMessage(session.conversationId, message, {
+            await sendMessageWithRetry(client, session.conversationId, message, {
+                messageId: buildCodexMessageId(session, 'failure'),
                 ...(session.activeSelfContextId
                     ? { selfContextId: session.activeSelfContextId }
                     : {}),
@@ -1347,6 +1512,7 @@ export async function main() {
             defaultPermissionMode: codexPermissionEnvelope.defaultPermissionMode,
             presentation: runtimePresentation,
             supportsPlanMode: useAppServer,
+            supportsRichCards: useAppServer,
         }),
     };
     async function baselineControlSignal(conversationId) {
@@ -1542,6 +1708,7 @@ export async function main() {
                 defaultPermissionMode: codexPermissionEnvelope.defaultPermissionMode,
                 presentation: runtimePresentation,
                 supportsPlanMode: useAppServer,
+                supportsRichCards: useAppServer,
             }),
         };
     }
@@ -1563,6 +1730,7 @@ export async function main() {
                 defaultPermissionMode: codexPermissionEnvelope.defaultPermissionMode,
                 presentation: runtimePresentation,
                 supportsPlanMode: useAppServer,
+                supportsRichCards: useAppServer,
             }),
         };
     }
@@ -1628,6 +1796,8 @@ export async function main() {
     });
     const pollControl = async () => {
         while (!controlStopped) {
+            const hadActiveWork = [...sessions.values()].some((session) => !session.closed
+                && (session.running || session.queue.length > 0 || session.turnState === 'waiting_input'));
             for (const conversationId of [...sessions.keys()]) {
                 try {
                     const controlRaw = await rtdbRead(`/control/${conversationId}/${agentId}/session`);
@@ -1696,14 +1866,14 @@ export async function main() {
                     session.turnState = 'interrupted';
                     writeTurn(session);
                     clearStreaming(conversationId);
-                    client.setTyping(conversationId, false).catch(() => { });
+                    typingSignals.clear(conversationId).catch(() => { });
                     await rtdbWrite(`/control/${conversationId}/${agentId}/signal`, null).catch(() => { });
                 }
                 catch {
                     // Ignore transient RTDB failures.
                 }
             }
-            await new Promise((resolve) => setTimeout(resolve, CONTROL_POLL_MS));
+            await new Promise((resolve) => setTimeout(resolve, controlPollDelayMs(hadActiveWork)));
         }
     };
     void pollControl();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@canonmsg/codex-plugin",
-  "version": "0.12.0",
+  "version": "0.13.1",
   "description": "Canon host integration for Codex CLI",
   "type": "module",
   "main": "dist/index.js",
@@ -29,8 +29,8 @@
     "prepack": "npm run build"
   },
   "dependencies": {
-    "@canonmsg/agent-sdk": "^2.0.0",
-    "@canonmsg/core": "^1.0.0"
+    "@canonmsg/agent-sdk": "^2.1.1",
+    "@canonmsg/core": "^1.3.0"
   },
   "engines": {
     "node": ">=18.0.0"