@syengup/friday-channel-next 1.0.0 → 1.0.3

package/dist/src/friday-session.js

@@ -321,6 +321,39 @@ export function forwardAgentEventRaw(evt) {
     if (typeof evt.stream === "string" && evt.stream.startsWith("codex_app_server")) {
         codexRunIds.add(evt.runId);
     }
+    // Codex app-server reasoning: newer OpenClaw cores stopped invoking the dispatch
+    // `onReasoningStream` callback (the A2 path in messages.ts) and instead stream the
+    // reasoning summary on the agent-event bus as `stream:"item" kind:"preamble"` with a
+    // cumulative `progressText` (source "codex-app-server"). The Friday app only renders
+    // `stream:"thinking"`, so translate it here — synthesize a thinking event reusing the
+    // cumulative→delta rewrite below. The raw preamble item is still forwarded but the app
+    // ignores unknown item kinds. (The onReasoningStream callback stays as a harmless
+    // fallback for cores that still fire it.)
+    if (evt.stream === "item" &&
+        evt.data.kind === "preamble" &&
+        evt.data.source === "codex-app-server") {
+        codexRunIds.add(evt.runId);
+        const reasoningText = typeof evt.data.progressText === "string" ? evt.data.progressText : "";
+        if (reasoningText) {
+            forwardAgentEventRaw({
+                runId: evt.runId,
+                stream: "thinking",
+                data: { text: reasoningText },
+                sessionKey: evt.sessionKey ?? sk,
+            });
+        }
+    }
+    // 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.0",
+  "version": "1.0.3",
   "description": "OpenClaw Friday Next Apple channel plugin",
   "license": "MIT",
   "type": "module",

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

@@ -139,6 +139,87 @@ describe("forwardAgentEventRaw (thinking delta rewrite)", () => {
     expect(third.delta).toBe(t1);
   });
 
+  it("translates a Codex preamble item (progressText) into streamed thinking deltas", () => {
+    // Newer OpenClaw cores stopped invoking dispatch onReasoningStream for Codex and instead
+    // stream the reasoning summary on the agent-event bus as item/preamble with cumulative
+    // progressText. We translate it back into stream:"thinking" so the app renders it.
+    forwardAgentEventRaw({
+      runId,
+      seq: 1,
+      stream: "item",
+      sessionKey,
+      data: { kind: "preamble", source: "codex-app-server", phase: "update", progressText: "先把" },
+    });
+    forwardAgentEventRaw({
+      runId,
+      seq: 2,
+      stream: "item",
+      sessionKey,
+      data: {
+        kind: "preamble",
+        source: "codex-app-server",
+        phase: "update",
+        progressText: "先把标准",
+      },
+    });
+
+    const thinking = (sseEmitter.broadcastToRun as ReturnType<typeof vi.fn>).mock.calls
+      .map((c) => c[1].data)
+      .filter((d: { stream?: string }) => d.stream === "thinking");
+    expect(thinking).toHaveLength(2);
+    expect(thinking[0].data.text).toBe("先把");
+    expect(thinking[0].data.delta).toBe("先把");
+    expect(thinking[0].data.reasoningPrefixChars).toBe(0);
+    expect(thinking[1].data.text).toBe("先把标准");
+    expect(thinking[1].data.delta).toBe("标准");
+    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,
+      seq: 1,
+      stream: "item",
+      sessionKey,
+      data: { kind: "preamble", source: "something-else", progressText: "x" },
+    });
+    const thinking = (sseEmitter.broadcastToRun as ReturnType<typeof vi.fn>).mock.calls
+      .map((c) => c[1].data)
+      .filter((d: { stream?: string }) => d.stream === "thinking");
+    expect(thinking).toHaveLength(0);
+  });
+
   it("merges run metadata into lifecycle.end (model, tokens, context usage)", () => {
     forwardAgentEventRaw({
       runId,

package/src/friday-session.ts

@@ -373,6 +373,43 @@ export function forwardAgentEventRaw(evt: ForwardAgentEventArgs): void {
     codexRunIds.add(evt.runId);
   }
 
+  // Codex app-server reasoning: newer OpenClaw cores stopped invoking the dispatch
+  // `onReasoningStream` callback (the A2 path in messages.ts) and instead stream the
+  // reasoning summary on the agent-event bus as `stream:"item" kind:"preamble"` with a
+  // cumulative `progressText` (source "codex-app-server"). The Friday app only renders
+  // `stream:"thinking"`, so translate it here — synthesize a thinking event reusing the
+  // cumulative→delta rewrite below. The raw preamble item is still forwarded but the app
+  // ignores unknown item kinds. (The onReasoningStream callback stays as a harmless
+  // fallback for cores that still fire it.)
+  if (
+    evt.stream === "item" &&
+    evt.data.kind === "preamble" &&
+    evt.data.source === "codex-app-server"
+  ) {
+    codexRunIds.add(evt.runId);
+    const reasoningText = typeof evt.data.progressText === "string" ? evt.data.progressText : "";
+    if (reasoningText) {
+      forwardAgentEventRaw({
+        runId: evt.runId,
+        stream: "thinking",
+        data: { text: reasoningText },
+        sessionKey: evt.sessionKey ?? sk,
+      });
+    }
+  }
+
+  // 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);
@@ -469,8 +506,7 @@ export function forwardAgentEventRaw(evt: ForwardAgentEventArgs): void {
   if (evt.stream === "lifecycle" && evt.data.phase === "start") {
     const announced = parseAnnounceRunId(evt.runId);
     if (announced) {
-      const entry =
-        lookupByChildSessionKey(announced.childSessionKey) ?? lookupByRunId(evt.runId);
+      const entry = lookupByChildSessionKey(announced.childSessionKey) ?? lookupByRunId(evt.runId);
       sseEmitter.broadcast(
         {
           type: "subagent",

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

package/dist/src/http 2/middleware/auth.d.ts

@@ -1,13 +0,0 @@
-/**
- * Bearer token authentication middleware for Friday HTTP routes.
- *
- * Validates that the bearer token matches the gateway's configured auth token.
- * This ensures plugin HTTP endpoints use the same token as gateway WS connections.
- */
-import type { IncomingMessage } from "node:http";
-/**
- * Extract and validate bearer token from Authorization header.
- * Returns the token only if it matches the gateway's configured auth token.
- * Returns null if token is missing, malformed, or doesn't match.
- */
-export declare function extractBearerToken(req: IncomingMessage): string | null;

package/dist/src/http 2/middleware/auth.js

@@ -1,29 +0,0 @@
-/**
- * Bearer token authentication middleware for Friday HTTP routes.
- *
- * Validates that the bearer token matches the gateway's configured auth token.
- * This ensures plugin HTTP endpoints use the same token as gateway WS connections.
- */
-import { resolveFridayNextConfig } from "../../config.js";
-import { getHostOpenClawConfigSnapshot } from "../../host-config.js";
-import { getFridayNextRuntime } from "../../runtime.js";
-/**
- * Extract and validate bearer token from Authorization header.
- * Returns the token only if it matches the gateway's configured auth token.
- * Returns null if token is missing, malformed, or doesn't match.
- */
-export function extractBearerToken(req) {
-    const auth = req.headers.authorization;
-    if (!auth || typeof auth !== "string")
-        return null;
-    const parts = auth.trim().split(/\s+/);
-    if (parts.length !== 2 || parts[0].toLowerCase() !== "bearer")
-        return null;
-    const token = parts[1];
-    // Validate token matches the gateway's configured auth token.
-    const cfg = getHostOpenClawConfigSnapshot(getFridayNextRuntime().config);
-    const runtimeConfig = resolveFridayNextConfig(cfg);
-    if (!runtimeConfig.authToken || token !== runtimeConfig.authToken)
-        return null;
-    return token;
-}

package/dist/src/http 2/middleware/body.d.ts

@@ -1,2 +0,0 @@
-import type { IncomingMessage } from "node:http";
-export declare function readJsonBody(req: IncomingMessage, maxBytes?: number): Promise<Record<string, unknown> | null>;

package/dist/src/http 2/middleware/body.js

@@ -1,24 +0,0 @@
-export async function readJsonBody(req, maxBytes = 2 * 1024 * 1024) {
-    return await new Promise((resolve) => {
-        const chunks = [];
-        let total = 0;
-        req.on("data", (chunk) => {
-            total += chunk.length;
-            if (total > maxBytes) {
-                resolve(null);
-                req.destroy();
-                return;
-            }
-            chunks.push(chunk);
-        });
-        req.on("end", () => {
-            try {
-                resolve(JSON.parse(Buffer.concat(chunks).toString("utf-8")));
-            }
-            catch {
-                resolve(null);
-            }
-        });
-        req.on("error", () => resolve(null));
-    });
-}

package/dist/src/http 2/middleware/cors.d.ts

@@ -1,2 +0,0 @@
-import type { ServerResponse } from "node:http";
-export declare function applyCorsHeaders(res: ServerResponse): void;

package/dist/src/http 2/middleware/cors.js

@@ -1,11 +0,0 @@
-import { resolveFridayNextConfig } from "../../config.js";
-import { getHostOpenClawConfigSnapshot } from "../../host-config.js";
-import { getFridayNextRuntime } from "../../runtime.js";
-export function applyCorsHeaders(res) {
-    const cfg = resolveFridayNextConfig(getHostOpenClawConfigSnapshot(getFridayNextRuntime().config));
-    if (!cfg.corsEnabled)
-        return;
-    res.setHeader("Access-Control-Allow-Origin", cfg.corsAllowOrigin || "*");
-    res.setHeader("Access-Control-Allow-Headers", "Authorization, Content-Type, Last-Event-ID");
-    res.setHeader("Access-Control-Allow-Methods", "GET,POST,OPTIONS");
-}