@canonmsg/codex-plugin 0.19.1 → 0.19.2

package/dist/adapter.d.ts

@@ -8,6 +8,7 @@ export type CodexEvent = {
 } | {
     type: 'message';
     text: string;
+    delta?: string;
     itemId?: string;
 } | {
     type: 'plan.updated';

package/dist/app-server-adapter.d.ts

@@ -39,6 +39,7 @@ export declare class CodexAppServerAdapter {
     private skillsCache;
     private messageTextByItem;
     private planText;
+    private traceTurnEpochMs;
     constructor(opts: {
         cwd: string;
         threadId?: string | null;
@@ -96,4 +97,6 @@ export declare class CodexAppServerAdapter {
     private clearActiveTurn;
     private sendRequest;
     private write;
+    private trace;
+    private traceLine;
 }

package/dist/app-server-adapter.js

@@ -31,6 +31,7 @@ export class CodexAppServerAdapter {
     skillsCache = null;
     messageTextByItem = new Map();
     planText = '';
+    traceTurnEpochMs = null;
     constructor(opts) {
         this.cwd = opts.cwd;
         this.threadId = opts.threadId ?? null;
@@ -117,6 +118,8 @@ export class CodexAppServerAdapter {
         this.interrupted = false;
         this.messageTextByItem.clear();
         this.planText = '';
+        this.traceTurnEpochMs = Date.now();
+        this.trace('turn/run begin');
         try {
             if (this.threadId && this.loadedThreadId !== this.threadId) {
                 const resumed = await this.sendRequest('thread/resume', {
@@ -158,9 +161,11 @@ export class CodexAppServerAdapter {
                 this.currentTurnReject = reject;
             });
             turnPromise.catch(() => { });
+            const turnInput = await this.buildTurnInput(prompt, imagePaths);
+            this.trace('turn/start sent');
             const turnStarted = await this.sendRequest('turn/start', {
                 threadId: this.threadId,
-                input: await this.buildTurnInput(prompt, imagePaths),
+                input: turnInput,
                 ...(this.model ? { model: this.model } : {}),
                 ...this.sandboxPolicyPayload(_extraAddDirs),
                 collaborationMode: {
@@ -172,6 +177,7 @@ export class CodexAppServerAdapter {
                     },
                 },
             });
+            this.trace('turn/start ack');
             const turn = turnStarted.turn;
             if (this.currentTurnResolve) {
                 this.currentTurnId = readString(turn, 'id') ?? null;
@@ -322,6 +328,7 @@ export class CodexAppServerAdapter {
         const message = parseJson(line);
         if (!message)
             return;
+        this.traceLine(line, message);
         if ('id' in message && ('result' in message || 'error' in message) && !('method' in message)) {
             const id = Number(message.id);
             const pending = this.pending.get(id);
@@ -395,7 +402,7 @@ export class CodexAppServerAdapter {
             this.messageTextByItem.set(itemId, next);
             this.currentFinalMessage = this.joinedAgentMessageText() ?? this.currentFinalMessage;
             if (next.trim())
-                this.currentOnEvent?.({ type: 'message', text: next, itemId });
+                this.currentOnEvent?.({ type: 'message', text: next, delta, itemId });
             return;
         }
         if (method === 'turn/plan/updated') {
@@ -467,6 +474,7 @@ export class CodexAppServerAdapter {
             return;
         }
         if (method === 'turn/completed') {
+            this.trace('turn/completed notification');
             const turn = params.turn;
             const status = turn?.status;
             if (isRecord(status) && status.type === 'failed') {
@@ -530,6 +538,7 @@ export class CodexAppServerAdapter {
         this.currentErrorText = null;
         this.messageTextByItem.clear();
         this.planText = '';
+        this.traceTurnEpochMs = null;
     }
     sendRequest(method, params) {
         const id = this.requestSeq++;
@@ -549,6 +558,33 @@ export class CodexAppServerAdapter {
             throw new Error('Codex app-server is not running');
         this.child.stdin.write(`${JSON.stringify(message)}\n`);
     }
+    trace(message) {
+        if (!isCodexTraceEnabled())
+            return;
+        const elapsedMs = this.traceTurnEpochMs === null ? 0 : Date.now() - this.traceTurnEpochMs;
+        console.error(`[canon-codex-trace] +${elapsedMs}ms ${message}`);
+    }
+    traceLine(line, message) {
+        if (!isCodexTraceEnabled())
+            return;
+        const method = typeof message.method === 'string' ? message.method : null;
+        if (!method) {
+            const id = 'id' in message ? ` id=${String(message.id)}` : '';
+            this.trace(`line bytes=${line.length} response${id}`);
+            return;
+        }
+        if (method === 'item/agentMessage/delta') {
+            const params = isRecord(message.params) ? message.params : {};
+            const itemId = readString(params, 'itemId') ?? 'agent-message';
+            const delta = readRawString(params, 'delta') ?? '';
+            this.trace(`line bytes=${line.length} method=${method} itemId=${itemId} deltaLen=${delta.length}`);
+            return;
+        }
+        this.trace(`line bytes=${line.length} method=${method}`);
+    }
+}
+function isCodexTraceEnabled() {
+    return process.env.CANON_CODEX_TRACE_EVENTS === '1';
 }
 function parseJson(line) {
     try {

package/dist/host.js

@@ -26,7 +26,7 @@ import { detectCodexCliVersion } from './codex-cli-version.js';
 import { buildCodexModelGuardMessage, formatCodexTurnFailure, isRecoverableCodexThreadError, } from './error-format.js';
 import { attachCodexControlNotifications } from './control-channel.js';
 import { runCli } from './cli-entry.js';
-import { beginCommandBlock, claimCommandBlock, createCommandBlockTracker, hasSpeechSegmentText, textSegmentBlockId, } from './turn-activity.js';
+import { beginCommandBlock, applyCodexMessageToStreamingOutput, claimCommandBlock, createCommandBlockTracker, hasSpeechSegmentText, } from './turn-activity.js';
 const HELP = `canon-codex — run a local Codex agent host for Canon
 
 USAGE
@@ -108,6 +108,35 @@ const CODEX_RUNTIME_CAPABILITIES = {
     supportsQueue: true,
     supportsNonFinalPermanentMessages: false,
 };
+function isCodexTraceEnabled() {
+    return process.env.CANON_CODEX_TRACE_EVENTS === '1';
+}
+function createCodexTracePort(port) {
+    if (!isCodexTraceEnabled())
+        return port;
+    return new Proxy(port, {
+        get(target, property, receiver) {
+            if (property !== 'publishStreaming') {
+                return Reflect.get(target, property, receiver);
+            }
+            return async (input) => {
+                const startedAt = Date.now();
+                const textLength = typeof input.text === 'string' ? input.text.length : 0;
+                console.error(`[canon-codex-trace] publishStreaming sent conversation=${input.conversationId} turn=${input.turnId ?? input.messageId ?? 'unknown'} textLen=${textLength}`);
+                try {
+                    const result = await target.publishStreaming(input);
+                    console.error(`[canon-codex-trace] publishStreaming ack conversation=${input.conversationId} ackMs=${Date.now() - startedAt}`);
+                    return result;
+                }
+                catch (error) {
+                    const message = error instanceof Error ? error.message : String(error);
+                    console.error(`[canon-codex-trace] publishStreaming error conversation=${input.conversationId} ackMs=${Date.now() - startedAt} error=${message}`);
+                    throw error;
+                }
+            };
+        },
+    });
+}
 // This host process resolves and locks exactly one agent profile. The lock
 // handle returned by resolveCanonAgent is held here so the top-level runCli
 // error handler (outside main's scope) can release it on a failed start —
@@ -554,7 +583,7 @@ export async function main() {
     });
     // The BridgeClient's zod-derived result shapes mirror the core wire types
     // structurally; the port pins the strong types the host machinery uses.
-    const port = bridge.client;
+    const port = createCodexTracePort(bridge.client);
     bridge.client.onProtocolError((error) => {
         console.error(`[canon-codex] Bridge protocol error: ${error.message}`);
     });
@@ -976,7 +1005,12 @@ export async function main() {
                                 session.turnState = 'streaming';
                                 writers.writeTurn();
                                 writers.stopVisibleWorkSignal();
-                                writers.streamingOutput.replaceTextSegmentSnapshot(textSegmentBlockId(session.currentTurnId, event.itemId), event.text);
+                                applyCodexMessageToStreamingOutput(writers.streamingOutput, {
+                                    turnId: session.currentTurnId,
+                                    itemId: event.itemId,
+                                    text: event.text,
+                                    delta: event.delta,
+                                });
                                 return;
                             }
                             if (event.type === 'plan.updated') {

package/dist/turn-activity.d.ts

@@ -24,6 +24,16 @@ export declare function createCommandBlockTracker(): CommandBlockTracker;
  * only owns the codex id scheme.
  */
 export declare function textSegmentBlockId(turnId: string | null | undefined, itemId?: string): string;
+export interface CodexTextSegmentOutput {
+    appendTextSegmentDelta(id: string, delta: string): void;
+    replaceTextSegmentSnapshot(id: string, text: string): void;
+}
+export declare function applyCodexMessageToStreamingOutput(output: CodexTextSegmentOutput, input: {
+    turnId: string | null | undefined;
+    itemId?: string;
+    text: string;
+    delta?: string;
+}): void;
 export declare function beginCommandBlock(tracker: CommandBlockTracker, input: {
     turnId: string | null | undefined;
     command: string;

package/dist/turn-activity.js

@@ -27,6 +27,14 @@ function normalizeOptionalString(value) {
 export function textSegmentBlockId(turnId, itemId) {
     return `message:${turnId ?? 'turn'}:${normalizeOptionalString(itemId) ?? 'latest'}`;
 }
+export function applyCodexMessageToStreamingOutput(output, input) {
+    const segmentId = textSegmentBlockId(input.turnId, input.itemId);
+    if (input.delta !== undefined) {
+        output.appendTextSegmentDelta(segmentId, input.delta);
+        return;
+    }
+    output.replaceTextSegmentSnapshot(segmentId, input.text);
+}
 function nextCommandBlockId(tracker, turnId, itemId) {
     const stableTurnId = turnId ?? 'turn';
     if (itemId)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@canonmsg/codex-plugin",
-  "version": "0.19.1",
+  "version": "0.19.2",
   "description": "Canon host integration for Codex CLI",
   "type": "module",
   "main": "dist/index.js",
@@ -29,11 +29,11 @@
     "prepack": "npm run build"
   },
   "dependencies": {
-    "@canonmsg/agent-host": "^0.3.0",
-    "@canonmsg/agent-sdk": "^3.4.3",
+    "@canonmsg/agent-host": "^0.4.0",
+    "@canonmsg/agent-sdk": "^3.4.4",
     "@canonmsg/backend-contracts": "^1.8.1",
     "@canonmsg/bridge": "^0.2.1",
-    "@canonmsg/core": "^3.1.1",
+    "@canonmsg/core": "^3.2.0",
     "@canonmsg/framework": "^0.2.1"
   },
   "engines": {