@syengup/friday-channel-next 0.1.13 → 0.1.14

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()];
@@ -153,9 +175,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 +223,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"]);
+  });
+});

package/src/history/normalize-message.ts

@@ -0,0 +1,292 @@
+/**
+ * Normalizes raw OpenClaw session transcript messages (as returned by the
+ * gateway `sessions.get` method / `runtime.subagent.getSessionMessages`) into a
+ * stable wire DTO the Friday app can parse without guessing at the upstream
+ * content-block shape.
+ *
+ * Each raw message is one persisted LLM message (UserMessage / AssistantMessage
+ * / ToolResultMessage) with an `__openclaw` metadata envelope attached by the
+ * gateway carrying the stable transcript entry `id`, a positional `seq`, and the
+ * record timestamp. That `id` is the durable, channel-agnostic identity the app
+ * uses as its sync/dedup key — runId is NOT persisted upstream.
+ */
+
+export interface FridayHistoryImage {
+  mimeType?: string;
+  /** Base64 payload for inline ImageContent blocks. */
+  data?: string;
+  /** URL for `[media attached: ...]` markers or resolved `MEDIA:` attachments. */
+  url?: string;
+  /** Display/download filename (set for resolved `MEDIA:` attachments). */
+  filename?: string;
+}
+
+export interface FridayHistoryToolCall {
+  id: string;
+  name: string;
+  arguments?: Record<string, unknown>;
+}
+
+export interface FridayHistoryToolResult {
+  toolCallId?: string;
+  toolName?: string;
+  isError?: boolean;
+  text?: string;
+  images?: FridayHistoryImage[];
+}
+
+export interface FridayHistoryUsage {
+  totalTokens?: number;
+  input?: number;
+  output?: number;
+}
+
+export type FridayHistoryRole = "user" | "assistant" | "toolResult" | "system";
+
+export interface FridayHistoryMessage {
+  /** Stable transcript entry id (sync key). Synthetic when upstream omitted it. */
+  id: string;
+  seq: number;
+  ts?: number;
+  role: FridayHistoryRole;
+  text?: string;
+  thinking?: string;
+  toolCalls?: FridayHistoryToolCall[];
+  toolResult?: FridayHistoryToolResult;
+  images?: FridayHistoryImage[];
+  /** Raw `MEDIA:<path>` server paths stripped from text; the handler resolves
+   *  them to downloadable `/friday-next/files/...` attachment URLs. */
+  mediaPaths?: string[];
+  model?: string;
+  usage?: FridayHistoryUsage;
+  /** Non-message records surfaced for context (e.g. compaction dividers). */
+  kind?: "compaction";
+  /** True when `id` was synthesized because upstream had no stable id. */
+  synthetic?: boolean;
+}
+
+type RawRecord = Record<string, unknown>;
+
+function asRecord(value: unknown): RawRecord | undefined {
+  return value && typeof value === "object" && !Array.isArray(value)
+    ? (value as RawRecord)
+    : undefined;
+}
+
+function readString(value: unknown): string | undefined {
+  return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+
+function readFiniteNumber(value: unknown): number | undefined {
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  if (typeof value === "string" && value.trim()) {
+    const n = Number(value);
+    if (Number.isFinite(n)) return n;
+  }
+  return undefined;
+}
+
+/** `MEDIA:<path>` lines emitted for outbound attachments (e.g. generated images). */
+const MEDIA_LINE_RE = /^[ \t]*MEDIA:[ \t]*(\S.*?)[ \t]*$/gim;
+
+/** Strips `MEDIA:<path>` lines from text, returning the cleaned text + the paths. */
+function splitMediaLines(text: string): { text: string; paths: string[] } {
+  if (!text.includes("MEDIA:")) return { text, paths: [] };
+  const paths: string[] = [];
+  const cleaned = text
+    .replace(MEDIA_LINE_RE, (_m, p: string) => {
+      const v = p.trim();
+      if (v) paths.push(v);
+      return "";
+    })
+    .replace(/\n{3,}/g, "\n\n")
+    .trim();
+  return { text: cleaned, paths };
+}
+
+const MEDIA_MARKER_RE = /\[media attached:\s*([^\]]+)\]/gi;
+
+/** Pull `[media attached: <url>]` markers out of free text into image refs. */
+function extractMediaMarkers(text: string): FridayHistoryImage[] {
+  const images: FridayHistoryImage[] = [];
+  for (const match of text.matchAll(MEDIA_MARKER_RE)) {
+    const url = match[1]?.trim();
+    if (url) images.push({ url });
+  }
+  return images;
+}
+
+interface ParsedContent {
+  text: string;
+  thinking: string;
+  toolCalls: FridayHistoryToolCall[];
+  images: FridayHistoryImage[];
+}
+
+function parseContent(content: unknown): ParsedContent {
+  const out: ParsedContent = { text: "", thinking: "", toolCalls: [], images: [] };
+
+  if (typeof content === "string") {
+    out.text = content;
+    out.images.push(...extractMediaMarkers(content));
+    return out;
+  }
+  if (!Array.isArray(content)) return out;
+
+  const textParts: string[] = [];
+  const thinkingParts: string[] = [];
+  for (const rawBlock of content) {
+    const block = asRecord(rawBlock);
+    if (!block) continue;
+    switch (block.type) {
+      case "text": {
+        const t = readString(block.text);
+        if (t) {
+          textParts.push(t);
+          out.images.push(...extractMediaMarkers(t));
+        }
+        break;
+      }
+      case "thinking": {
+        const t = readString(block.thinking);
+        if (t) thinkingParts.push(t);
+        break;
+      }
+      case "image": {
+        const data = readString(block.data);
+        const url = readString(block.url);
+        // Skip empty image blocks (no payload and no URL) — they'd render as
+        // broken attachment bubbles in the app.
+        if (data || url) {
+          out.images.push({
+            ...(readString(block.mimeType) ? { mimeType: readString(block.mimeType) } : {}),
+            ...(data ? { data } : {}),
+            ...(url ? { url } : {}),
+          });
+        }
+        break;
+      }
+      case "toolCall": {
+        const id = readString(block.id);
+        const name = readString(block.name);
+        if (id && name) {
+          out.toolCalls.push({
+            id,
+            name,
+            ...(asRecord(block.arguments) ? { arguments: asRecord(block.arguments) } : {}),
+          });
+        }
+        break;
+      }
+      default:
+        break;
+    }
+  }
+  out.text = textParts.join("");
+  out.thinking = thinkingParts.join("");
+  return out;
+}
+
+function parseUsage(raw: unknown): FridayHistoryUsage | undefined {
+  const usage = asRecord(raw);
+  if (!usage) return undefined;
+  const totalTokens = readFiniteNumber(usage.totalTokens) ?? readFiniteNumber(usage.total);
+  const input = readFiniteNumber(usage.input);
+  const output = readFiniteNumber(usage.output);
+  if (totalTokens === undefined && input === undefined && output === undefined) return undefined;
+  return {
+    ...(totalTokens !== undefined ? { totalTokens } : {}),
+    ...(input !== undefined ? { input } : {}),
+    ...(output !== undefined ? { output } : {}),
+  };
+}
+
+function normalizeRole(raw: unknown): FridayHistoryRole {
+  const role = readString(raw)?.toLowerCase();
+  switch (role) {
+    case "user":
+      return "user";
+    case "toolresult":
+      return "toolResult";
+    case "system":
+      return "system";
+    default:
+      return "assistant";
+  }
+}
+
+/**
+ * Normalize one raw transcript message. `index` is the position in the returned
+ * batch, used only to synthesize a stable-ish id when upstream omits one.
+ */
+export function normalizeHistoryMessage(
+  raw: unknown,
+  index: number,
+): FridayHistoryMessage | null {
+  const record = asRecord(raw);
+  if (!record) return null;
+
+  const meta = asRecord(record.__openclaw);
+  const role = normalizeRole(record.role);
+  const parsed = parseContent(record.content);
+
+  const seq = readFiniteNumber(meta?.seq) ?? index + 1;
+  const metaId = readString(meta?.id);
+  const id = metaId ?? `seq:${seq}`;
+  const synthetic = metaId === undefined;
+  const ts = readFiniteNumber(meta?.recordTimestampMs) ?? readFiniteNumber(record.timestamp);
+  const kind = readString(meta?.kind) === "compaction" ? "compaction" : undefined;
+
+  const message: FridayHistoryMessage = {
+    id,
+    seq,
+    role,
+    ...(ts !== undefined ? { ts } : {}),
+    ...(synthetic ? { synthetic: true } : {}),
+    ...(kind ? { kind } : {}),
+  };
+
+  if (kind === "compaction") {
+    message.text = parsed.text || "Compaction";
+    return message;
+  }
+
+  if (role === "toolResult") {
+    const split = splitMediaLines(parsed.text);
+    const toolResult: FridayHistoryToolResult = {
+      ...(readString(record.toolCallId) ? { toolCallId: readString(record.toolCallId) } : {}),
+      ...(readString(record.toolName) ? { toolName: readString(record.toolName) } : {}),
+      ...(record.isError === true ? { isError: true } : {}),
+      ...(split.text ? { text: split.text } : {}),
+      ...(parsed.images.length ? { images: parsed.images } : {}),
+    };
+    message.toolResult = toolResult;
+    if (split.paths.length) message.mediaPaths = split.paths;
+    return message;
+  }
+
+  const split = splitMediaLines(parsed.text);
+  if (split.text) message.text = split.text;
+  if (split.paths.length) message.mediaPaths = split.paths;
+  if (parsed.thinking) message.thinking = parsed.thinking;
+  if (parsed.toolCalls.length) message.toolCalls = parsed.toolCalls;
+  if (parsed.images.length) message.images = parsed.images;
+
+  const model = readString(record.model) ?? readString(record.responseModel);
+  if (model) message.model = model;
+  const usage = parseUsage(record.usage);
+  if (usage) message.usage = usage;
+
+  return message;
+}
+
+/** Normalize a batch of raw transcript messages, dropping unparseable entries. */
+export function normalizeHistoryMessages(rawMessages: unknown[]): FridayHistoryMessage[] {
+  const out: FridayHistoryMessage[] = [];
+  for (let i = 0; i < rawMessages.length; i += 1) {
+    const normalized = normalizeHistoryMessage(rawMessages[i], i);
+    if (normalized) out.push(normalized);
+  }
+  out.sort((a, b) => a.seq - b.seq);
+  return out;
+}