@lobu/worker 6.1.1 → 7.0.0

package/src/__tests__/memory-flush-harden.test.ts

@@ -0,0 +1,367 @@
+/**
+ * Hardening tests for memory-flush and estimatePromptTokenCost.
+ *
+ * Covers gaps in memory-flush.test.ts and memory-flush-runtime.test.ts:
+ * - resolveMemoryFlushConfig with null compaction / deeply-nested invalid values
+ * - resolveMemoryFlushConfig enabled=false prevents flush
+ * - estimatePromptTokenCost with edge values (0 chars, negative image count)
+ * - maybeRunPreCompactionMemoryFlush: flush skipped when config.enabled=false
+ * - maybeRunPreCompactionMemoryFlush: flush skipped when projected tokens are below threshold
+ * - maybeRunPreCompactionMemoryFlush: 'stored' outcome recorded correctly
+ * - getLatestAssistantText: multi-block content and NO_REPLY case-insensitivity
+ */
+
+import { beforeEach, describe, expect, test } from "bun:test";
+import { SettingsManager } from "@mariozechner/pi-coding-agent";
+import {
+  OpenClawWorker,
+  estimatePromptTokenCost,
+  resolveMemoryFlushConfig,
+} from "../openclaw/worker";
+import { mockWorkerConfig } from "./setup";
+
+// ---------------------------------------------------------------------------
+// resolveMemoryFlushConfig edge cases
+// ---------------------------------------------------------------------------
+
+describe("resolveMemoryFlushConfig — edge cases", () => {
+  test("null compaction falls back to defaults", () => {
+    const cfg = resolveMemoryFlushConfig({ compaction: null } as any);
+    expect(cfg.enabled).toBe(true);
+    expect(cfg.softThresholdTokens).toBe(4000);
+  });
+
+  test("compaction is a number (not object) falls back to defaults", () => {
+    const cfg = resolveMemoryFlushConfig({ compaction: 42 } as any);
+    expect(cfg.enabled).toBe(true);
+  });
+
+  test("memoryFlush.softThresholdTokens=0 is valid (non-negative)", () => {
+    const cfg = resolveMemoryFlushConfig({
+      compaction: { memoryFlush: { softThresholdTokens: 0 } },
+    });
+    expect(cfg.softThresholdTokens).toBe(0);
+  });
+
+  test("memoryFlush.softThresholdTokens=Infinity is invalid → fallback", () => {
+    const cfg = resolveMemoryFlushConfig({
+      compaction: { memoryFlush: { softThresholdTokens: Infinity } },
+    } as any);
+    expect(cfg.softThresholdTokens).toBe(4000);
+  });
+
+  test("memoryFlush.softThresholdTokens=NaN is invalid → fallback", () => {
+    const cfg = resolveMemoryFlushConfig({
+      compaction: { memoryFlush: { softThresholdTokens: NaN } },
+    } as any);
+    expect(cfg.softThresholdTokens).toBe(4000);
+  });
+
+  test("enabled=false is preserved", () => {
+    const cfg = resolveMemoryFlushConfig({
+      compaction: { memoryFlush: { enabled: false } },
+    });
+    expect(cfg.enabled).toBe(false);
+  });
+
+  test("systemPrompt whitespace-only falls back to default", () => {
+    const cfg = resolveMemoryFlushConfig({
+      compaction: { memoryFlush: { systemPrompt: "   " } },
+    });
+    expect(cfg.systemPrompt).toBe(
+      "Session nearing compaction. Store durable memories now."
+    );
+  });
+
+  test("prompt whitespace-only falls back to default", () => {
+    const cfg = resolveMemoryFlushConfig({
+      compaction: { memoryFlush: { prompt: "\t\n" } },
+    });
+    expect(cfg.prompt).toContain("NO_REPLY");
+  });
+
+  test("extra unknown keys in memoryFlush are ignored", () => {
+    const cfg = resolveMemoryFlushConfig({
+      compaction: {
+        memoryFlush: {
+          enabled: true,
+          softThresholdTokens: 2000,
+          unknownKey: "value",
+        },
+      },
+    } as any);
+    expect(cfg.softThresholdTokens).toBe(2000);
+    expect((cfg as any).unknownKey).toBeUndefined();
+  });
+});
+
+// ---------------------------------------------------------------------------
+// estimatePromptTokenCost edge cases
+// ---------------------------------------------------------------------------
+
+describe("estimatePromptTokenCost — edge cases", () => {
+  test("empty string with no images costs 0", () => {
+    expect(estimatePromptTokenCost("", 0)).toBe(0);
+  });
+
+  test("negative image count is treated as 0", () => {
+    expect(estimatePromptTokenCost("abcd", -5)).toBe(1);
+  });
+
+  test("4-char string costs 1 token", () => {
+    expect(estimatePromptTokenCost("abcd", 0)).toBe(1);
+  });
+
+  test("5-char string costs 2 tokens (ceil)", () => {
+    expect(estimatePromptTokenCost("abcde", 0)).toBe(2);
+  });
+
+  test("each image adds ~1200 tokens", () => {
+    const oneImage = estimatePromptTokenCost("", 1);
+    const twoImages = estimatePromptTokenCost("", 2);
+    expect(twoImages - oneImage).toBe(1200);
+  });
+
+  test("large text + multiple images combine additively", () => {
+    const textTokens = Math.ceil("hello world".length / 4); // 3
+    const imageTokens = 3 * 1200;
+    expect(estimatePromptTokenCost("hello world", 3)).toBe(
+      textTokens + imageTokens
+    );
+  });
+});
+
+// ---------------------------------------------------------------------------
+// maybeRunPreCompactionMemoryFlush: enabled=false skips flush
+// ---------------------------------------------------------------------------
+
+describe("maybeRunPreCompactionMemoryFlush — enabled=false", () => {
+  beforeEach(() => {
+    process.env.DISPATCHER_URL = "https://test-dispatcher.example.com";
+    process.env.WORKER_TOKEN = "test-worker-token";
+  });
+
+  test("skips flush when memoryFlushConfig.enabled=false regardless of context usage", async () => {
+    const worker = new OpenClawWorker(mockWorkerConfig);
+    const settingsManager = SettingsManager.inMemory();
+
+    let silentCallCount = 0;
+    const session = {
+      getContextUsage: () => ({
+        tokens: 99000,
+        contextWindow: 100000,
+        percent: 99,
+        usageTokens: 99000,
+        trailingTokens: 0,
+        lastUsageIndex: 1,
+      }),
+      messages: [],
+    } as any;
+
+    const sessionManager = {
+      getBranch: () => [],
+      appendCustomEntry: () => undefined,
+    } as any;
+
+    await (worker as any).maybeRunPreCompactionMemoryFlush({
+      session,
+      sessionManager,
+      settingsManager,
+      memoryFlushConfig: {
+        enabled: false,
+        softThresholdTokens: 4000,
+        systemPrompt: "Store now.",
+        prompt: "Reply with NO_REPLY.",
+      },
+      incomingPromptText: "hello",
+      incomingImageCount: 0,
+      runSilentPrompt: async () => {
+        silentCallCount += 1;
+      },
+    });
+
+    expect(silentCallCount).toBe(0);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// maybeRunPreCompactionMemoryFlush: 'stored' outcome
+// ---------------------------------------------------------------------------
+
+describe("maybeRunPreCompactionMemoryFlush — 'stored' outcome", () => {
+  beforeEach(() => {
+    process.env.DISPATCHER_URL = "https://test-dispatcher.example.com";
+    process.env.WORKER_TOKEN = "test-worker-token";
+  });
+
+  test("records 'stored' outcome when latest assistant message is not NO_REPLY", async () => {
+    const worker = new OpenClawWorker(mockWorkerConfig);
+    const settingsManager = SettingsManager.inMemory();
+
+    const branchEntries: Array<Record<string, unknown>> = [];
+    const sessionManager = {
+      getBranch: () => branchEntries as any,
+      appendCustomEntry: (customType: string, data: unknown) => {
+        branchEntries.push({
+          type: "custom",
+          id: crypto.randomUUID(),
+          parentId: null,
+          timestamp: new Date().toISOString(),
+          customType,
+          data,
+        });
+      },
+    } as any;
+
+    const session = {
+      getContextUsage: () => ({
+        tokens: 95000,
+        contextWindow: 100000,
+        percent: 95,
+        usageTokens: 95000,
+        trailingTokens: 0,
+        lastUsageIndex: 1,
+      }),
+      messages: [
+        {
+          role: "assistant",
+          content: "I stored the key information in memory.",
+        },
+      ],
+    } as any;
+
+    await (worker as any).maybeRunPreCompactionMemoryFlush({
+      session,
+      sessionManager,
+      settingsManager,
+      memoryFlushConfig: {
+        enabled: true,
+        softThresholdTokens: 4000,
+        systemPrompt: "Store now.",
+        prompt: "Reply with NO_REPLY.",
+      },
+      incomingPromptText: "hello",
+      incomingImageCount: 0,
+      runSilentPrompt: async () => undefined,
+    });
+
+    const state = branchEntries.find((e) => e.type === "custom") as any;
+    expect(state?.data?.outcome).toBe("stored");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// maybeRunPreCompactionMemoryFlush: NO_REPLY is case-insensitive
+// ---------------------------------------------------------------------------
+
+describe("maybeRunPreCompactionMemoryFlush — NO_REPLY case-insensitivity", () => {
+  beforeEach(() => {
+    process.env.DISPATCHER_URL = "https://test-dispatcher.example.com";
+    process.env.WORKER_TOKEN = "test-worker-token";
+  });
+
+  test("lowercase 'no_reply' is treated as NO_REPLY outcome", async () => {
+    const worker = new OpenClawWorker(mockWorkerConfig);
+    const settingsManager = SettingsManager.inMemory();
+
+    const branchEntries: Array<Record<string, unknown>> = [];
+    const sessionManager = {
+      getBranch: () => branchEntries as any,
+      appendCustomEntry: (customType: string, data: unknown) => {
+        branchEntries.push({
+          type: "custom",
+          id: crypto.randomUUID(),
+          parentId: null,
+          timestamp: new Date().toISOString(),
+          customType,
+          data,
+        });
+      },
+    } as any;
+
+    const session = {
+      getContextUsage: () => ({
+        tokens: 95000,
+        contextWindow: 100000,
+        percent: 95,
+        usageTokens: 95000,
+        trailingTokens: 0,
+        lastUsageIndex: 1,
+      }),
+      messages: [{ role: "assistant", content: "no_reply" }],
+    } as any;
+
+    await (worker as any).maybeRunPreCompactionMemoryFlush({
+      session,
+      sessionManager,
+      settingsManager,
+      memoryFlushConfig: {
+        enabled: true,
+        softThresholdTokens: 4000,
+        systemPrompt: "Store now.",
+        prompt: "Reply with NO_REPLY.",
+      },
+      incomingPromptText: "hello",
+      incomingImageCount: 0,
+      runSilentPrompt: async () => undefined,
+    });
+
+    const state = branchEntries.find((e) => e.type === "custom") as any;
+    expect(state?.data?.outcome).toBe("no_reply");
+  });
+
+  test("array-content NO_REPLY is detected", async () => {
+    const worker = new OpenClawWorker(mockWorkerConfig);
+    const settingsManager = SettingsManager.inMemory();
+
+    const branchEntries: Array<Record<string, unknown>> = [];
+    const sessionManager = {
+      getBranch: () => branchEntries as any,
+      appendCustomEntry: (customType: string, data: unknown) => {
+        branchEntries.push({
+          type: "custom",
+          id: crypto.randomUUID(),
+          parentId: null,
+          timestamp: new Date().toISOString(),
+          customType,
+          data,
+        });
+      },
+    } as any;
+
+    const session = {
+      getContextUsage: () => ({
+        tokens: 95000,
+        contextWindow: 100000,
+        percent: 95,
+        usageTokens: 95000,
+        trailingTokens: 0,
+        lastUsageIndex: 1,
+      }),
+      messages: [
+        {
+          role: "assistant",
+          content: [{ type: "text", text: "NO_REPLY" }],
+        },
+      ],
+    } as any;
+
+    await (worker as any).maybeRunPreCompactionMemoryFlush({
+      session,
+      sessionManager,
+      settingsManager,
+      memoryFlushConfig: {
+        enabled: true,
+        softThresholdTokens: 4000,
+        systemPrompt: "Store now.",
+        prompt: "Reply with NO_REPLY.",
+      },
+      incomingPromptText: "hi",
+      incomingImageCount: 0,
+      runSilentPrompt: async () => undefined,
+    });
+
+    const state = branchEntries.find((e) => e.type === "custom") as any;
+    expect(state?.data?.outcome).toBe("no_reply");
+  });
+});

package/src/__tests__/memory-flush-runtime.test.ts

@@ -0,0 +1,138 @@
+import { beforeEach, describe, expect, test } from "bun:test";
+import { SettingsManager } from "@mariozechner/pi-coding-agent";
+import { OpenClawWorker } from "../openclaw/worker";
+import { mockWorkerConfig } from "./setup";
+
+describe("pre-compaction memory flush runtime", () => {
+  beforeEach(() => {
+    process.env.DISPATCHER_URL = "https://test-dispatcher.example.com";
+    process.env.WORKER_TOKEN = "test-worker-token";
+  });
+
+  test("runs silent flush once per compaction cycle and persists NO_REPLY outcome", async () => {
+    const worker = new OpenClawWorker(mockWorkerConfig);
+    const settingsManager = SettingsManager.inMemory();
+
+    const branchEntries: Array<Record<string, unknown>> = [];
+    const sessionManager = {
+      getBranch: () => branchEntries as any,
+      appendCustomEntry: (customType: string, data: unknown) => {
+        branchEntries.push({
+          type: "custom",
+          id: crypto.randomUUID(),
+          parentId: null,
+          timestamp: new Date().toISOString(),
+          customType,
+          data,
+        });
+      },
+    } as any;
+
+    let silentCallCount = 0;
+    const session = {
+      getContextUsage: () => ({
+        tokens: 90000,
+        contextWindow: 100000,
+        percent: 90,
+        usageTokens: 90000,
+        trailingTokens: 0,
+        lastUsageIndex: 1,
+      }),
+      messages: [
+        {
+          role: "assistant",
+          content: "  no_reply  ",
+        },
+      ],
+    } as any;
+
+    const invokeFlush = async () => {
+      await (worker as any).maybeRunPreCompactionMemoryFlush({
+        session,
+        sessionManager,
+        settingsManager,
+        memoryFlushConfig: {
+          enabled: true,
+          softThresholdTokens: 4000,
+          systemPrompt: "Session nearing compaction.",
+          prompt: "Reply with NO_REPLY.",
+        },
+        incomingPromptText: "hello",
+        incomingImageCount: 0,
+        runSilentPrompt: async () => {
+          silentCallCount += 1;
+        },
+      });
+    };
+
+    await invokeFlush();
+    expect(silentCallCount).toBe(1);
+
+    const flushStateEntry = branchEntries.find(
+      (entry) => entry.type === "custom"
+    ) as any;
+    expect(flushStateEntry?.customType).toBe("lobu.memory_flush_state");
+    expect(flushStateEntry?.data?.outcome).toBe("no_reply");
+    expect(flushStateEntry?.data?.compactionCount).toBe(0);
+
+    // Same compaction cycle: should not flush again.
+    await invokeFlush();
+    expect(silentCallCount).toBe(1);
+
+    // New compaction entry means a new cycle: flush should run again.
+    branchEntries.push({
+      type: "compaction",
+      id: crypto.randomUUID(),
+      parentId: null,
+      timestamp: new Date().toISOString(),
+      summary: "compacted",
+      firstKeptEntryId: "abc",
+      tokensBefore: 123,
+    });
+
+    await invokeFlush();
+    expect(silentCallCount).toBe(2);
+  });
+
+  test("skips flush when projected context is below threshold", async () => {
+    const worker = new OpenClawWorker(mockWorkerConfig);
+    const settingsManager = SettingsManager.inMemory();
+
+    const sessionManager = {
+      getBranch: () => [] as any,
+      appendCustomEntry: () => undefined,
+    } as any;
+
+    let silentCallCount = 0;
+    const session = {
+      getContextUsage: () => ({
+        tokens: 1000,
+        contextWindow: 200000,
+        percent: 0.5,
+        usageTokens: 1000,
+        trailingTokens: 0,
+        lastUsageIndex: 1,
+      }),
+      messages: [],
+    } as any;
+
+    await (worker as any).maybeRunPreCompactionMemoryFlush({
+      session,
+      sessionManager,
+      settingsManager,
+      memoryFlushConfig: {
+        enabled: true,
+        softThresholdTokens: 4000,
+        systemPrompt: "Session nearing compaction.",
+        prompt: "Reply with NO_REPLY.",
+      },
+      incomingPromptText: "short prompt",
+      incomingImageCount: 0,
+      runSilentPrompt: async () => {
+        silentCallCount += 1;
+      },
+    });
+
+    expect(silentCallCount).toBe(0);
+  });
+});

package/src/__tests__/memory-flush.test.ts

@@ -0,0 +1,64 @@
+import { describe, expect, test } from "bun:test";
+import {
+  estimatePromptTokenCost,
+  resolveMemoryFlushConfig,
+} from "../openclaw/worker";
+
+describe("memory flush config", () => {
+  test("uses defaults when config missing", () => {
+    const cfg = resolveMemoryFlushConfig({});
+    expect(cfg.enabled).toBe(true);
+    expect(cfg.softThresholdTokens).toBe(4000);
+    expect(cfg.systemPrompt).toBe(
+      "Session nearing compaction. Store durable memories now."
+    );
+    expect(cfg.prompt).toContain("Reply with NO_REPLY");
+  });
+
+  test("uses configured memory flush options", () => {
+    const cfg = resolveMemoryFlushConfig({
+      compaction: {
+        memoryFlush: {
+          enabled: false,
+          softThresholdTokens: 1234,
+          systemPrompt: "  custom system  ",
+          prompt: "  custom prompt  ",
+        },
+      },
+    });
+
+    expect(cfg).toEqual({
+      enabled: false,
+      softThresholdTokens: 1234,
+      systemPrompt: "custom system",
+      prompt: "custom prompt",
+    });
+  });
+
+  test("falls back for invalid values", () => {
+    const cfg = resolveMemoryFlushConfig({
+      compaction: {
+        memoryFlush: {
+          enabled: "yes",
+          softThresholdTokens: -10,
+          systemPrompt: "   ",
+          prompt: 123,
+        },
+      },
+    } as unknown as Record<string, unknown>);
+
+    expect(cfg.enabled).toBe(true);
+    expect(cfg.softThresholdTokens).toBe(4000);
+    expect(cfg.systemPrompt).toBe(
+      "Session nearing compaction. Store durable memories now."
+    );
+    expect(cfg.prompt).toContain("Reply with NO_REPLY");
+  });
+});
+
+describe("estimatePromptTokenCost", () => {
+  test("includes text and image token estimates", () => {
+    expect(estimatePromptTokenCost("1234", 0)).toBe(1);
+    expect(estimatePromptTokenCost("1234", 2)).toBe(2401);
+  });
+});