@syengup/friday-channel-next 1.0.1 → 1.0.3

package/dist/src/friday-session.js

@@ -343,6 +343,17 @@ export function forwardAgentEventRaw(evt) {
             });
         }
     }
+    // Codex app-server projects every tool/command call onto BOTH the standard `tool` stream
+    // (carrying args + the real result) AND a redundant `item` event (kind:"tool"/"command"),
+    // and core flags that item `suppressChannelProgress: true` ("do not surface in channel
+    // progress"). Forwarding the suppressed item anyway double-renders every non-exec tool in
+    // the app — the `tool`-stream row plus a second `item kind:tool` row, with the result landing
+    // only on the first. Honor the flag and drop suppressed items; the `tool` stream (and, for
+    // exec, the synthesized `command_output`) already carries everything the app renders. Codex
+    // reasoning items (preamble/analysis) are NOT suppressed, so this never touches thinking.
+    if (evt.stream === "item" && evt.data.suppressChannelProgress === true) {
+        return;
+    }
     // Register sessionKey → runId so we can resolve parentRunId
     if (sk && evt.stream === "lifecycle" && evt.data.phase === "start") {
         registerSessionKeyForRun(sk, evt.runId);

package/dist/src/http/handlers/messages.js

@@ -467,6 +467,16 @@ export async function handleMessages(req, res) {
                     runId,
                     suppressTyping: true,
                     disableBlockStreaming: true,
+                    // friday-next is a direct device channel: the final assistant reply auto-delivers
+                    // to the app live over SSE (sendText), and the channel already declares ChatType
+                    // "direct" + outbound.deliveryMode "direct". But OpenClaw core's source-reply policy
+                    // (resolveSourceReplyDeliveryMode) can still resolve `message_tool_only` for this
+                    // channel from its own defaults — when it does, the agent prompt tells the model
+                    // "visible replies are NOT auto-delivered; use message(action=send) for everything",
+                    // which makes Codex route its whole answer through the `message` tool (and that tool
+                    // crashes on friday-next). Pin `automatic` so core honors the channel's own direct
+                    // delivery and never instructs the model to deliver via the message tool.
+                    sourceReplyDeliveryMode: "automatic",
                     // A1: feed the chosen thinking level into the run as a one-shot override so the model
                     // request asks for a reasoning summary. The session-stored `thinkingLevel` alone is NOT
                     // honored by the reply dispatch; `thinkingLevelOverride` has top priority in OpenClaw's

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@syengup/friday-channel-next",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "description": "OpenClaw Friday Next Apple channel plugin",
   "license": "MIT",
   "type": "module",

package/src/friday-session.forward-agent.test.ts

@@ -175,6 +175,37 @@ describe("forwardAgentEventRaw (thinking delta rewrite)", () => {
     expect(thinking[1].data.reasoningPrefixChars).toBe(2);
   });
 
+  it("drops item events flagged suppressChannelProgress (Codex tool/command duplicates)", () => {
+    // Codex app-server projects every tool/command onto both the `tool` stream and a redundant
+    // `item` event flagged suppressChannelProgress:true. Forwarding the item double-renders the
+    // tool in the app. We honor the flag and drop it.
+    forwardAgentEventRaw({
+      runId,
+      seq: 1,
+      stream: "item",
+      sessionKey,
+      data: {
+        itemId: "call_abc",
+        kind: "tool",
+        phase: "start",
+        name: "web_search",
+        suppressChannelProgress: true,
+      },
+    });
+    expect(sseEmitter.broadcastToRun).not.toHaveBeenCalled();
+  });
+
+  it("forwards item events that are not suppressed (e.g. reasoning analysis markers)", () => {
+    forwardAgentEventRaw({
+      runId,
+      seq: 1,
+      stream: "item",
+      sessionKey,
+      data: { itemId: "rs_1", kind: "analysis", phase: "start", title: "Reasoning" },
+    });
+    expect(sseEmitter.broadcastToRun).toHaveBeenCalledTimes(1);
+  });
+
   it("does not translate preamble items from a non-Codex source", () => {
     forwardAgentEventRaw({
       runId,

package/src/friday-session.ts

@@ -398,6 +398,18 @@ export function forwardAgentEventRaw(evt: ForwardAgentEventArgs): void {
     }
   }
 
+  // Codex app-server projects every tool/command call onto BOTH the standard `tool` stream
+  // (carrying args + the real result) AND a redundant `item` event (kind:"tool"/"command"),
+  // and core flags that item `suppressChannelProgress: true` ("do not surface in channel
+  // progress"). Forwarding the suppressed item anyway double-renders every non-exec tool in
+  // the app — the `tool`-stream row plus a second `item kind:tool` row, with the result landing
+  // only on the first. Honor the flag and drop suppressed items; the `tool` stream (and, for
+  // exec, the synthesized `command_output`) already carries everything the app renders. Codex
+  // reasoning items (preamble/analysis) are NOT suppressed, so this never touches thinking.
+  if (evt.stream === "item" && evt.data.suppressChannelProgress === true) {
+    return;
+  }
+
   // Register sessionKey → runId so we can resolve parentRunId
   if (sk && evt.stream === "lifecycle" && evt.data.phase === "start") {
     registerSessionKeyForRun(sk, evt.runId);

package/src/http/handlers/messages.ts

@@ -635,6 +635,16 @@ export async function handleMessages(req: IncomingMessage, res: ServerResponse):
           runId,
           suppressTyping: true,
           disableBlockStreaming: true,
+          // friday-next is a direct device channel: the final assistant reply auto-delivers
+          // to the app live over SSE (sendText), and the channel already declares ChatType
+          // "direct" + outbound.deliveryMode "direct". But OpenClaw core's source-reply policy
+          // (resolveSourceReplyDeliveryMode) can still resolve `message_tool_only` for this
+          // channel from its own defaults — when it does, the agent prompt tells the model
+          // "visible replies are NOT auto-delivered; use message(action=send) for everything",
+          // which makes Codex route its whole answer through the `message` tool (and that tool
+          // crashes on friday-next). Pin `automatic` so core honors the channel's own direct
+          // delivery and never instructs the model to deliver via the message tool.
+          sourceReplyDeliveryMode: "automatic",
           // A1: feed the chosen thinking level into the run as a one-shot override so the model
           // request asks for a reasoning summary. The session-stored `thinkingLevel` alone is NOT
           // honored by the reply dispatch; `thinkingLevelOverride` has top priority in OpenClaw's