@syengup/friday-channel-next 0.1.13 → 0.1.15

package/src/agent-forward-runtime.ts

@@ -6,6 +6,14 @@ export type FridayAgentForwardRuntime = {
     path: string,
     options?: { skipCache?: boolean; maintenanceConfig?: unknown; clone?: boolean },
   ) => Record<string, unknown>;
+  /** Cache-owning entry write (syncs the app session name → server `displayName`). */
+  updateSessionStoreEntry?: (params: {
+    storePath: string;
+    sessionKey: string;
+    update: (
+      entry: Record<string, unknown>,
+    ) => Record<string, unknown> | null | Promise<Record<string, unknown> | null>;
+  }) => Promise<Record<string, unknown> | null>;
   getConfig: () => unknown;
 };
 
@@ -16,6 +24,8 @@ export function setFridayAgentForwardRuntime(api: OpenClawPluginApi): void {
   forwardRuntime = {
     resolveStorePath: api.runtime.agent.session.resolveStorePath,
     loadSessionStore: api.runtime.agent.session.loadSessionStore,
+    updateSessionStoreEntry: (api.runtime.agent.session as Record<string, unknown>)
+      .updateSessionStoreEntry as FridayAgentForwardRuntime["updateSessionStoreEntry"],
     getConfig: () => api.runtime.config.current(),
   };
 }

package/src/channel-actions.test.ts

@@ -0,0 +1,111 @@
+import fs from "node:fs";
+import path from "node:path";
+import { EventEmitter } from "node:events";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { handleMessageAction } from "./channel-actions.js";
+import { sseEmitter } from "./sse/emitter.js";
+import { setOfflineQueueBaseDirForTest } from "./sse/offline-queue.js";
+import { registerRunRoute } from "./run-metadata.js";
+import { createTempHistoryDir, removeTempHistoryDir, setMockRuntime } from "./test-support/mock-runtime.js";
+
+/**
+ * The `message` tool's `action=send` is handled here (NOT via outbound.sendText/sendMedia).
+ * `ctx.sessionKey` is the agent's base/main session, so the send must recover the app session that
+ * started the device's active run from the run-route registry — otherwise attachments land in a
+ * device-level / main session instead of the user's current session.
+ */
+
+class MockRes extends EventEmitter {
+  writes: string[] = [];
+  write(chunk: string): boolean {
+    this.writes.push(chunk);
+    return true;
+  }
+  end(): void {
+    // no-op
+  }
+}
+
+type OutboundFrame = { type: string; data: Record<string, unknown> };
+
+function parseOutboundFrames(res: MockRes): OutboundFrame[] {
+  const frames: OutboundFrame[] = [];
+  for (const block of res.writes.join("").split("\n\n")) {
+    if (!block.trim()) continue;
+    let type = "";
+    let data: Record<string, unknown> | undefined;
+    for (const line of block.split("\n")) {
+      if (line.startsWith("event: ")) type = line.slice("event: ".length).trim();
+      else if (line.startsWith("data: ")) {
+        try {
+          data = JSON.parse(line.slice("data: ".length));
+        } catch {
+          // ignore
+        }
+      }
+    }
+    if (data) frames.push({ type, data });
+  }
+  return frames;
+}
+
+describe("channel-actions handleSend sessionKey routing", () => {
+  let historyDir = "";
+
+  beforeEach(() => {
+    sseEmitter.resetForTest();
+    historyDir = createTempHistoryDir();
+    setOfflineQueueBaseDirForTest(historyDir);
+    setMockRuntime({ historyDir, authToken: "test-token" });
+  });
+
+  afterEach(() => {
+    setOfflineQueueBaseDirForTest(null);
+    removeTempHistoryDir(historyDir);
+  });
+
+  function connect(deviceId: string): MockRes {
+    const res = new MockRes();
+    sseEmitter.addConnection(deviceId, res as never);
+    return res;
+  }
+
+  it("send media routes to the active run's app session, not ctx.sessionKey", async () => {
+    const deviceId = "DEV-ACT-1";
+    const runId = "run-act-1";
+    const appSession = "agent:operator:friday:direct:dev-act-1:1780561609";
+    const mediaFile = path.join(historyDir, "shot.png");
+    fs.writeFileSync(mediaFile, "png-bytes");
+    registerRunRoute({ runId, deviceId, sessionKey: appSession });
+    sseEmitter.trackDeviceForRun(deviceId, runId);
+    const res = connect(deviceId);
+
+    const result = await handleMessageAction({
+      action: "send",
+      params: { to: deviceId, message: "桌面截图来了 📸", media: mediaFile },
+      sessionKey: "agent:operator:main", // ctx gives the base/main session — must be overridden
+    });
+
+    expect((result as { ok?: boolean }).ok).toBe(true);
+    const frames = parseOutboundFrames(res);
+    const media = frames.find((f) => f.type === "outbound" && f.data.op === "media");
+    const text = frames.find((f) => f.type === "outbound" && f.data.op === "text");
+    expect(media?.data.sessionKey).toBe(appSession);
+    expect(text?.data.sessionKey).toBe(appSession);
+    expect(media?.data.deviceId).toBe(deviceId);
+  });
+
+  it("falls back to ctx.sessionKey when the device has no active run-route", async () => {
+    const deviceId = "DEV-ACT-2";
+    const res = connect(deviceId);
+
+    await handleMessageAction({
+      action: "send",
+      params: { to: deviceId, message: "hi" },
+      sessionKey: "agent:operator:friday:direct:fallback-session",
+    });
+
+    const text = parseOutboundFrames(res).find((f) => f.type === "outbound" && f.data.op === "text");
+    expect(text?.data.sessionKey).toBe("agent:operator:friday:direct:fallback-session");
+  });
+});

package/src/channel-actions.ts

@@ -2,6 +2,8 @@ import crypto from "node:crypto";
 import fs from "node:fs";
 import { sseEmitter } from "./sse/emitter.js";
 import { guessMimeType } from "./http/handlers/files.js";
+import { getRunRoute } from "./run-metadata.js";
+import { resolveHistorySessionKeyForFridayDevice } from "./friday-session.js";
 
 type MessageActionCtx = {
   action: string;
@@ -64,7 +66,14 @@ async function handleSend(ctx: MessageActionCtx): Promise<unknown> {
   }
 
   const runId = crypto.randomUUID();
-  const sessionKey = ctx.sessionKey ?? undefined;
+  // The `message` tool's send runs as a fresh action; `ctx.sessionKey` is the agent's base/main
+  // session, not the app session that started the active run on this device. Recover the latter via
+  // the device's last tracked run-route so attachments land in the user's current session.
+  const activeRunId = sseEmitter.getLastRunIdForDevice(to) ?? undefined;
+  const sessionKey =
+    (activeRunId ? getRunRoute(activeRunId)?.sessionKey : undefined) ??
+    ctx.sessionKey ??
+    resolveHistorySessionKeyForFridayDevice(to);
 
   // Send text via SSE outbound
   if (text) {

package/src/channel.outbound-mirror-suppression.test.ts

@@ -0,0 +1,36 @@
+import { describe, expect, it } from "vitest";
+import { fridayNextChannelPlugin } from "./channel.js";
+
+/**
+ * friday-next is a transparent proxy: outbound attachments/text already reach the app
+ * live via SSE (sendText/sendMedia/handleSend). OpenClaw core's generic outbound path
+ * additionally mirrors message-tool sends into the *recipient's* session transcript
+ * (model:"delivery-mirror"). For friday-next that recipient session falls back to
+ * `agent:<agentId>:friday-next:direct:<deviceId>` — an orphan session unrelated to the
+ * app's real conversation — producing a phantom session + a stray delivery-mirror message.
+ *
+ * The core consults `messaging.resolveOutboundSessionRoute` FIRST; returning `null`
+ * short-circuits route resolution so no orphan session entry and no delivery-mirror are
+ * created. This test pins that contract.
+ */
+describe("friday-next channel suppresses core delivery-mirror", () => {
+  const messaging = (fridayNextChannelPlugin as { messaging?: Record<string, unknown> }).messaging;
+
+  it("exposes resolveOutboundSessionRoute on the messaging adapter", () => {
+    expect(typeof messaging?.resolveOutboundSessionRoute).toBe("function");
+  });
+
+  it("returns null for any outbound target so no mirror session is routed", async () => {
+    const resolve = messaging?.resolveOutboundSessionRoute as (
+      params: Record<string, unknown>,
+    ) => unknown;
+    const route = await resolve({
+      cfg: {},
+      agentId: "operator",
+      channel: "friday-next",
+      target: "9cd3d546-b230-40ab-b931-bb2e8305e38c",
+      currentSessionKey: "agent:operator:friday-next:9cd3d546",
+    });
+    expect(route).toBeNull();
+  });
+});

package/src/channel.outbound.test.ts

@@ -0,0 +1,137 @@
+import fs from "node:fs";
+import path from "node:path";
+import { EventEmitter } from "node:events";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { fridayNextChannelPlugin } from "./channel.js";
+import { sseEmitter } from "./sse/emitter.js";
+import { setOfflineQueueBaseDirForTest } from "./sse/offline-queue.js";
+import { registerRunRoute } from "./run-metadata.js";
+import { createTempHistoryDir, removeTempHistoryDir, setMockRuntime } from "./test-support/mock-runtime.js";
+
+/**
+ * Outbound (message-tool send) must route to the session that started the run.
+ *
+ * OpenClaw's `ChannelOutboundContext` does not carry the originating sessionKey, so the channel
+ * recovers it from the run-route registry via the device's last tracked runId. Without this the
+ * media/text would land in a device-level fallback session, not the user's current session.
+ */
+
+class MockRes extends EventEmitter {
+  writes: string[] = [];
+  write(chunk: string): boolean {
+    this.writes.push(chunk);
+    return true;
+  }
+  end(): void {
+    // no-op
+  }
+}
+
+type OutboundFrame = { type: string; data: Record<string, unknown> };
+
+function parseOutboundFrames(res: MockRes): OutboundFrame[] {
+  const frames: OutboundFrame[] = [];
+  for (const block of res.writes.join("").split("\n\n")) {
+    if (!block.trim()) continue;
+    let type = "";
+    let data: Record<string, unknown> | undefined;
+    for (const line of block.split("\n")) {
+      if (line.startsWith("event: ")) type = line.slice("event: ".length).trim();
+      else if (line.startsWith("data: ")) {
+        try {
+          data = JSON.parse(line.slice("data: ".length));
+        } catch {
+          // ignore non-JSON
+        }
+      }
+    }
+    if (data) frames.push({ type, data });
+  }
+  return frames;
+}
+
+const outbound = fridayNextChannelPlugin.outbound as {
+  sendText: (ctx: Record<string, unknown>) => Promise<unknown>;
+  sendMedia: (ctx: Record<string, unknown>) => Promise<unknown>;
+};
+
+describe("friday-next channel outbound sessionKey routing", () => {
+  let historyDir = "";
+
+  beforeEach(() => {
+    sseEmitter.resetForTest();
+    historyDir = createTempHistoryDir();
+    setOfflineQueueBaseDirForTest(historyDir);
+    setMockRuntime({ historyDir, authToken: "test-token" });
+  });
+
+  afterEach(() => {
+    setOfflineQueueBaseDirForTest(null);
+    removeTempHistoryDir(historyDir);
+  });
+
+  function connect(deviceId: string): MockRes {
+    const res = new MockRes();
+    sseEmitter.addConnection(deviceId, res as never);
+    return res;
+  }
+
+  it("sendText carries the run's sessionKey (recovered via run-route)", async () => {
+    const deviceId = "DEV-TEXT-1";
+    const runId = "run-text-1";
+    const sessionKey = "agent:operator:friday-next:direct:abc-text";
+    registerRunRoute({ runId, deviceId, sessionKey });
+    sseEmitter.trackDeviceForRun(deviceId, runId);
+    const res = connect(deviceId);
+
+    await outbound.sendText({ to: deviceId, text: "hi" });
+
+    const evt = parseOutboundFrames(res).find((f) => f.type === "outbound" && f.data.op === "text");
+    expect(evt).toBeDefined();
+    expect(evt?.data.sessionKey).toBe(sessionKey);
+    expect(evt?.data.deviceId).toBe(deviceId);
+  });
+
+  it("run-route wins over ctx sessionKey (ctx carries the agent's base/main session, not the active app session)", async () => {
+    const deviceId = "DEV-TEXT-2";
+    const runId = "run-text-2";
+    registerRunRoute({ runId, deviceId, sessionKey: "agent:operator:friday-next:direct:route-session" });
+    sseEmitter.trackDeviceForRun(deviceId, runId);
+    const res = connect(deviceId);
+
+    await outbound.sendText({ to: deviceId, text: "hi", requesterSessionKey: "agent:operator:main" });
+
+    const evt = parseOutboundFrames(res).find((f) => f.type === "outbound" && f.data.op === "text");
+    expect(evt?.data.sessionKey).toBe("agent:operator:friday-next:direct:route-session");
+  });
+
+  it("falls back to device-level session when no run-route exists", async () => {
+    const deviceId = "DEV-TEXT-3";
+    sseEmitter.trackDeviceForRun(deviceId, "run-text-3-untracked");
+    const res = connect(deviceId);
+
+    await outbound.sendText({ to: deviceId, text: "hi" });
+
+    const evt = parseOutboundFrames(res).find((f) => f.type === "outbound" && f.data.op === "text");
+    // No mapping registered for this device → synthesized device-level fallback.
+    expect(evt?.data.sessionKey).toBe(`agent:main:friday-next-${deviceId}`);
+  });
+
+  it("sendMedia carries the run's sessionKey (recovered via run-route)", async () => {
+    const deviceId = "DEV-MEDIA-1";
+    const runId = "run-media-1";
+    const sessionKey = "agent:operator:friday-next:direct:abc-media";
+    const mediaFile = path.join(historyDir, "shot.png");
+    fs.writeFileSync(mediaFile, "png-bytes");
+    registerRunRoute({ runId, deviceId, sessionKey });
+    sseEmitter.trackDeviceForRun(deviceId, runId);
+    const res = connect(deviceId);
+
+    await outbound.sendMedia({ to: deviceId, text: "caption", mediaUrl: mediaFile });
+
+    const evt = parseOutboundFrames(res).find((f) => f.type === "outbound" && f.data.op === "media");
+    expect(evt).toBeDefined();
+    expect(evt?.data.sessionKey).toBe(sessionKey);
+    expect(evt?.data.deviceId).toBe(deviceId);
+  });
+});

package/src/channel.ts

@@ -19,6 +19,7 @@ import {
   resolveFridayDeviceIdForOutbound,
   resolveHistorySessionKeyForFridayDevice,
 } from "./friday-session.js";
+import { getRunRoute } from "./run-metadata.js";
 import { getLastFridayInboundAt } from "./friday-inbound-stats.js";
 
 const logger = createFridayNextLogger("channel");
@@ -32,6 +33,27 @@ function pickFirstString(source: Record<string, unknown>, keys: string[]): strin
   return undefined;
 }
 
+/**
+ * Resolve the sessionKey for an outbound message-tool send.
+ *
+ * OpenClaw's `ChannelOutboundContext` does not carry the originating run's sessionKey, so the raw
+ * ctx is almost always missing it. We recover the current run's session via the run-route registry
+ * (keyed by the device's last tracked runId) so message-tool text/media land in the session that
+ * triggered the run — not a device-level fallback. Falls back to the device's latest history session
+ * for cron / offline / no-run paths.
+ */
+function resolveOutboundSessionKey(
+  deviceId: string,
+  runId: string | undefined,
+  rawCtx: Record<string, unknown>,
+): string | undefined {
+  return (
+    (runId ? getRunRoute(runId)?.sessionKey : undefined) ??
+    pickFirstString(rawCtx, ["requesterSessionKey", "sessionKey"]) ??
+    resolveHistorySessionKeyForFridayDevice(deviceId)
+  );
+}
+
 function resolveLocalMediaPath(mediaUrl: string, localRoots?: string[]): string {
   if (path.isAbsolute(mediaUrl)) return mediaUrl;
   const roots = localRoots ?? [process.cwd(), os.tmpdir()];
@@ -138,6 +160,15 @@ export const fridayNextChannelPlugin = createChatChannelPlugin({
       },
       parseExplicitTarget: () => ({ to: "friday-next" }),
       formatTargetDisplay: ({ display }: any) => display || "Friday Next",
+      // friday-next is a transparent proxy: outbound text/media already reach the app live
+      // via SSE (sendText/sendMedia/handleSend). The OpenClaw core additionally mirrors
+      // message-tool sends into the recipient's session transcript (model:"delivery-mirror").
+      // For friday-next that recipient session falls back to
+      // `agent:<agentId>:friday-next:direct:<deviceId>` — an orphan session unrelated to the
+      // app's real conversation — spawning a phantom session + a stray delivery-mirror message.
+      // The core checks this hook first; returning null short-circuits route resolution so no
+      // orphan session entry and no delivery-mirror are written.
+      resolveOutboundSessionRoute: () => null,
     },
   },
   outbound: {
@@ -153,9 +184,7 @@ export const fridayNextChannelPlugin = createChatChannelPlugin({
           "runId",
         ]);
         const runId = runIdFromCtx ?? sseEmitter.getLastRunIdForDevice(deviceId) ?? undefined;
-        const sessionKey =
-          pickFirstString(rawCtx, ["requesterSessionKey", "sessionKey"]) ??
-          resolveHistorySessionKeyForFridayDevice(deviceId);
+        const sessionKey = resolveOutboundSessionKey(deviceId, runId, rawCtx);
 
         const conn = sseEmitter.getConnection(deviceId);
         const ts = new Date().toISOString();
@@ -203,9 +232,7 @@ export const fridayNextChannelPlugin = createChatChannelPlugin({
           "runId",
         ]);
         const runId = runIdFromCtx ?? sseEmitter.getLastRunIdForDevice(deviceId) ?? undefined;
-        const sessionKey =
-          pickFirstString(rawCtx, ["requesterSessionKey", "sessionKey"]) ??
-          resolveHistorySessionKeyForFridayDevice(deviceId);
+        const sessionKey = resolveOutboundSessionKey(deviceId, runId, rawCtx);
         const audioAsVoice = ctx.audioAsVoice === true;
         const caption = ctx.text ?? "";
 

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

@@ -0,0 +1,154 @@
+import { describe, it, expect } from "vitest";
+import {
+  normalizeHistoryMessage,
+  normalizeHistoryMessages,
+} from "./normalize-message.js";
+
+function meta(id?: string, seq = 1, extra: Record<string, unknown> = {}) {
+  return { __openclaw: { ...(id ? { id } : {}), seq, recordTimestampMs: 1700000000000, ...extra } };
+}
+
+describe("normalizeHistoryMessage", () => {
+  it("returns null for non-object input", () => {
+    expect(normalizeHistoryMessage("nope", 0)).toBeNull();
+    expect(normalizeHistoryMessage(null, 0)).toBeNull();
+    expect(normalizeHistoryMessage([], 0)).toBeNull();
+  });
+
+  it("normalizes a string-content user message and carries the stable id + ts", () => {
+    const out = normalizeHistoryMessage(
+      { role: "user", content: "hello", ...meta("entry-1", 3) },
+      7,
+    );
+    expect(out).toMatchObject({
+      id: "entry-1",
+      seq: 3,
+      ts: 1700000000000,
+      role: "user",
+      text: "hello",
+    });
+    expect(out?.synthetic).toBeUndefined();
+  });
+
+  it("synthesizes an id and flags synthetic when upstream omits __openclaw.id", () => {
+    const out = normalizeHistoryMessage({ role: "user", content: "hi", __openclaw: { seq: 5 } }, 0);
+    expect(out?.id).toBe("seq:5");
+    expect(out?.synthetic).toBe(true);
+  });
+
+  it("falls back to batch index for seq when missing", () => {
+    const out = normalizeHistoryMessage({ role: "user", content: "hi" }, 4);
+    expect(out?.seq).toBe(5);
+    expect(out?.id).toBe("seq:5");
+  });
+
+  it("parses assistant text + thinking + toolCall blocks and model/usage", () => {
+    const out = normalizeHistoryMessage(
+      {
+        role: "assistant",
+        model: "openai/gpt-4",
+        usage: { input: 10, output: 20, totalTokens: 30 },
+        content: [
+          { type: "thinking", thinking: "let me think" },
+          { type: "text", text: "the answer" },
+          { type: "toolCall", id: "tc-1", name: "search", arguments: { q: "x" } },
+        ],
+        ...meta("entry-2", 2),
+      },
+      0,
+    );
+    expect(out?.text).toBe("the answer");
+    expect(out?.thinking).toBe("let me think");
+    expect(out?.toolCalls).toEqual([{ id: "tc-1", name: "search", arguments: { q: "x" } }]);
+    expect(out?.model).toBe("openai/gpt-4");
+    expect(out?.usage).toEqual({ input: 10, output: 20, totalTokens: 30 });
+  });
+
+  it("parses inline image content blocks", () => {
+    const out = normalizeHistoryMessage(
+      {
+        role: "user",
+        content: [
+          { type: "text", text: "look" },
+          { type: "image", mimeType: "image/png", data: "BASE64" },
+        ],
+        ...meta("entry-img", 1),
+      },
+      0,
+    );
+    expect(out?.text).toBe("look");
+    expect(out?.images).toEqual([{ mimeType: "image/png", data: "BASE64" }]);
+  });
+
+  it("extracts [media attached: ...] markers from text into image urls", () => {
+    const out = normalizeHistoryMessage(
+      { role: "user", content: "see [media attached: file:///a.jpg]", ...meta("m", 1) },
+      0,
+    );
+    expect(out?.images).toEqual([{ url: "file:///a.jpg" }]);
+  });
+
+  it("normalizes a toolResult message", () => {
+    const out = normalizeHistoryMessage(
+      {
+        role: "toolResult",
+        toolCallId: "tc-1",
+        toolName: "search",
+        isError: false,
+        content: [{ type: "text", text: "result text" }],
+        ...meta("entry-tr", 4),
+      },
+      0,
+    );
+    expect(out?.role).toBe("toolResult");
+    expect(out?.toolResult).toEqual({
+      toolCallId: "tc-1",
+      toolName: "search",
+      text: "result text",
+    });
+  });
+
+  it("strips MEDIA: lines from text into mediaPaths", () => {
+    const out = normalizeHistoryMessage(
+      {
+        role: "assistant",
+        content: "Here is the serene landscape 🌅\nMEDIA:/Users/me/.openclaw/media/tool-image-generation/x.png",
+        ...meta("a1", 1),
+      },
+      0,
+    );
+    expect(out?.text).toBe("Here is the serene landscape 🌅");
+    expect(out?.mediaPaths).toEqual(["/Users/me/.openclaw/media/tool-image-generation/x.png"]);
+  });
+
+  it("captures multiple MEDIA: lines and leaves text without markers untouched", () => {
+    const out = normalizeHistoryMessage(
+      { role: "assistant", content: "two files\nMEDIA:/a/x.png\nMEDIA:/a/y.mp4", ...meta("a2", 1) },
+      0,
+    );
+    expect(out?.text).toBe("two files");
+    expect(out?.mediaPaths).toEqual(["/a/x.png", "/a/y.mp4"]);
+    const plain = normalizeHistoryMessage({ role: "user", content: "no media here", ...meta("u", 1) }, 0);
+    expect(plain?.mediaPaths).toBeUndefined();
+  });
+
+  it("flags compaction records via __openclaw.kind", () => {
+    const out = normalizeHistoryMessage(
+      { role: "system", content: [{ type: "text", text: "Compaction" }], ...meta("c1", 9, { kind: "compaction" }) },
+      0,
+    );
+    expect(out?.kind).toBe("compaction");
+    expect(out?.role).toBe("system");
+  });
+});
+
+describe("normalizeHistoryMessages", () => {
+  it("drops unparseable entries and sorts by seq", () => {
+    const result = normalizeHistoryMessages([
+      { role: "assistant", content: "b", __openclaw: { id: "b", seq: 2 } },
+      "garbage",
+      { role: "user", content: "a", __openclaw: { id: "a", seq: 1 } },
+    ]);
+    expect(result.map((m) => m.id)).toEqual(["a", "b"]);
+  });
+});