@syengup/friday-channel-next 1.0.1 → 1.0.4

package/dist/index.js

@@ -16,8 +16,6 @@ import { ensureCodexReasoningSummary } from "./src/codex-reasoning-config.js";
 const hookLogger = createFridayNextLogger("hook");
 export { fridayNextChannelPlugin } from "./src/channel.js";
 export { setFridayNextRuntime } from "./src/runtime.js";
-/** `api.on` returns void — register tool hooks at most once per process. */
-let fridayNextToolHooksRegistered = false;
 let disposeAgentEventListener = null;
 /**
  * Track the last `api` instance on which HTTP routes were registered.
@@ -142,10 +140,17 @@ export default defineChannelPluginEntry({
                 total: event.usage?.total,
             }, event.model, event.provider);
         });
-        if (fridayNextToolHooksRegistered) {
+        // Tool hooks (subagent_delivery_target / before_tool_call / after_tool_call) must follow the
+        // SAME re-registration discipline as the HTTP routes and onAgentEvent listener above. When the
+        // health-monitor restarts the plugin, `registerFull` receives a fresh `api` and the host
+        // dispatches hooks on THAT api; hooks left bound to the first api go silent for the rest of the
+        // process. The old one-time boolean guard bound them to whichever api arrived first — which is
+        // exactly why Codex `command_output` (the A3 after_tool_call stdout synthesis) fired on some
+        // gateway processes and not others. Re-register on every genuinely-new api; skip only a repeat
+        // call with the same api (matching the `!sameApi` gate the routes use).
+        if (sameApi) {
             return;
         }
-        fridayNextToolHooksRegistered = true;
         // Make Codex (ChatGPT/OAuth) models emit reasoning summary text so the app can stream
         // "thinking". OpenClaw never sets this; we assert it on the plugin side. Best-effort.
         ensureCodexReasoningSummary((msg) => hookLogger.info(msg));

package/dist/src/friday-session.js

@@ -343,6 +343,23 @@ 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 *tool* item 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. So drop ONLY suppressed `kind:"tool"` items.
+    //
+    // BUT keep suppressed `kind:"command"`/`"process"` items: the `tool` stream's exec result is
+    // just {exitCode,duration} (no stdout), and the app bootstraps its command-terminal row from
+    // the `item kind:command` event — that row is what the synthesized `command_output` end event
+    // then attaches the real stdout to. Dropping it left exec tools with a command line and no
+    // output in the trace. (Reasoning items preamble/analysis are never suppressed.)
+    if (evt.stream === "item" &&
+        evt.data.suppressChannelProgress === true &&
+        evt.data.kind === "tool") {
+        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/history/normalize-message.js

@@ -91,6 +91,21 @@ function parseContent(content) {
                 }
                 break;
             }
+            case "toolResult":
+            case "tool_result": {
+                // Codex (app-server backend) persists an exec/bash tool's STDOUT in a content
+                // block whose `type` is "toolResult" (not "text") — the output lives in the
+                // block's `text`/`content`. The native/Anthropic path uses plain "text" blocks,
+                // so this case was never hit and the command output was silently dropped from
+                // history (`parsed.text` stayed ""), leaving the app's trace tool row with no
+                // result. ControlUI shows it because its projection reads these blocks.
+                const t = readString(block.text) || readString(block.content);
+                if (t) {
+                    textParts.push(t);
+                    out.images.push(...extractMediaMarkers(t));
+                }
+                break;
+            }
             case "thinking": {
                 const t = readString(block.thinking);
                 if (t)

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/index.ts

@@ -30,8 +30,6 @@ const hookLogger = createFridayNextLogger("hook");
 export { fridayNextChannelPlugin } from "./src/channel.js";
 export { setFridayNextRuntime } from "./src/runtime.js";
 
-/** `api.on` returns void — register tool hooks at most once per process. */
-let fridayNextToolHooksRegistered = false;
 let disposeAgentEventListener: (() => void) | null = null;
 /**
  * Track the last `api` instance on which HTTP routes were registered.
@@ -163,10 +161,17 @@ export default defineChannelPluginEntry({
       );
     });
 
-    if (fridayNextToolHooksRegistered) {
+    // Tool hooks (subagent_delivery_target / before_tool_call / after_tool_call) must follow the
+    // SAME re-registration discipline as the HTTP routes and onAgentEvent listener above. When the
+    // health-monitor restarts the plugin, `registerFull` receives a fresh `api` and the host
+    // dispatches hooks on THAT api; hooks left bound to the first api go silent for the rest of the
+    // process. The old one-time boolean guard bound them to whichever api arrived first — which is
+    // exactly why Codex `command_output` (the A3 after_tool_call stdout synthesis) fired on some
+    // gateway processes and not others. Re-register on every genuinely-new api; skip only a repeat
+    // call with the same api (matching the `!sameApi` gate the routes use).
+    if (sameApi) {
       return;
     }
-    fridayNextToolHooksRegistered = true;
 
     // Make Codex (ChatGPT/OAuth) models emit reasoning summary text so the app can stream
     // "thinking". OpenClaw never sets this; we assert it on the plugin side. Best-effort.

package/package.json

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

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

@@ -175,6 +175,58 @@ 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("KEEPS suppressed item kind:command (exec row the command_output stdout attaches to)", () => {
+    // The `tool`-stream exec result is just {exitCode,duration}; the real stdout arrives on the
+    // synthesized `command_output` end event, which the app attaches to the command-terminal row
+    // bootstrapped from THIS `item kind:command`. Dropping it (as the old broad filter did) left
+    // exec tools with a command line and no output in the trace.
+    forwardAgentEventRaw({
+      runId,
+      seq: 1,
+      stream: "item",
+      sessionKey,
+      data: {
+        itemId: "call_exec1",
+        kind: "command",
+        phase: "start",
+        name: "bash",
+        suppressChannelProgress: true,
+      },
+    });
+    expect(sseEmitter.broadcastToRun).toHaveBeenCalledTimes(1);
+  });
+
+  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,26 @@ 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 *tool* item 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. So drop ONLY suppressed `kind:"tool"` items.
+  //
+  // BUT keep suppressed `kind:"command"`/`"process"` items: the `tool` stream's exec result is
+  // just {exitCode,duration} (no stdout), and the app bootstraps its command-terminal row from
+  // the `item kind:command` event — that row is what the synthesized `command_output` end event
+  // then attaches the real stdout to. Dropping it left exec tools with a command line and no
+  // output in the trace. (Reasoning items preamble/analysis are never suppressed.)
+  if (
+    evt.stream === "item" &&
+    evt.data.suppressChannelProgress === true &&
+    evt.data.kind === "tool"
+  ) {
+    return;
+  }
+
   // Register sessionKey → runId so we can resolve parentRunId
   if (sk && evt.stream === "lifecycle" && evt.data.phase === "start") {
     registerSessionKeyForRun(sk, evt.runId);

package/src/history/normalize-message.test.ts

@@ -185,6 +185,33 @@ describe("normalizeHistoryMessage", () => {
     expect(plain?.mediaPaths).toBeUndefined();
   });
 
+  it("extracts Codex exec stdout from a `toolResult`-typed content block", () => {
+    // Codex (app-server) persists bash/exec stdout in a content block whose `type` is
+    // "toolResult" (not "text"); the native path only ever emits "text" blocks. Before the
+    // fix this fell through `default` and the command output was dropped (text="").
+    const out = normalizeHistoryMessage(
+      {
+        role: "toolResult",
+        toolCallId: "call_GSu3",
+        toolName: "bash",
+        content: [
+          {
+            type: "toolResult",
+            toolCallId: "call_GSu3",
+            name: "bash",
+            content: "Applications\nDesktop\nDocuments",
+            text: "Applications\nDesktop\nDocuments",
+          },
+        ],
+        ...meta("tr-1", 3),
+      },
+      0,
+    );
+    expect(out?.role).toBe("toolResult");
+    expect(out?.toolResult?.text).toBe("Applications\nDesktop\nDocuments");
+    expect(out?.toolResult?.toolCallId).toBe("call_GSu3");
+  });
+
   it("flags compaction records via __openclaw.kind", () => {
     const out = normalizeHistoryMessage(
       {

package/src/history/normalize-message.ts

@@ -158,6 +158,21 @@ function parseContent(content: unknown): ParsedContent {
         }
         break;
       }
+      case "toolResult":
+      case "tool_result": {
+        // Codex (app-server backend) persists an exec/bash tool's STDOUT in a content
+        // block whose `type` is "toolResult" (not "text") — the output lives in the
+        // block's `text`/`content`. The native/Anthropic path uses plain "text" blocks,
+        // so this case was never hit and the command output was silently dropped from
+        // history (`parsed.text` stayed ""), leaving the app's trace tool row with no
+        // result. ControlUI shows it because its projection reads these blocks.
+        const t = readString(block.text) || readString(block.content);
+        if (t) {
+          textParts.push(t);
+          out.images.push(...extractMediaMarkers(t));
+        }
+        break;
+      }
       case "thinking": {
         const t = readString(block.thinking);
         if (t) thinkingParts.push(t);

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