@lobu/worker 3.0.9 → 3.0.13

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

@@ -1,138 +0,0 @@
-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

@@ -1,64 +0,0 @@
-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);
-  });
-});

package/src/__tests__/model-resolver.test.ts

@@ -1,156 +0,0 @@
-import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-import {
-  DEFAULT_PROVIDER_BASE_URL_ENV,
-  DEFAULT_PROVIDER_MODELS,
-  PROVIDER_REGISTRY_ALIASES,
-  registerDynamicProvider,
-  resolveModelRef,
-} from "../openclaw/model-resolver";
-
-describe("resolveModelRef", () => {
-  let originalDefaultModel: string | undefined;
-  let originalDefaultProvider: string | undefined;
-
-  beforeEach(() => {
-    originalDefaultModel = process.env.AGENT_DEFAULT_MODEL;
-    originalDefaultProvider = process.env.AGENT_DEFAULT_PROVIDER;
-    delete process.env.AGENT_DEFAULT_MODEL;
-    delete process.env.AGENT_DEFAULT_PROVIDER;
-  });
-
-  afterEach(() => {
-    if (originalDefaultModel !== undefined)
-      process.env.AGENT_DEFAULT_MODEL = originalDefaultModel;
-    else delete process.env.AGENT_DEFAULT_MODEL;
-    if (originalDefaultProvider !== undefined)
-      process.env.AGENT_DEFAULT_PROVIDER = originalDefaultProvider;
-    else delete process.env.AGENT_DEFAULT_PROVIDER;
-  });
-
-  test("parses provider/model format", () => {
-    const result = resolveModelRef("anthropic/claude-sonnet-4-20250514");
-    expect(result.provider).toBe("anthropic");
-    expect(result.modelId).toBe("claude-sonnet-4-20250514");
-  });
-
-  test("handles model with slashes (e.g. provider/org/model)", () => {
-    const result = resolveModelRef("openai/gpt-4.1");
-    expect(result.provider).toBe("openai");
-    expect(result.modelId).toBe("gpt-4.1");
-  });
-
-  test("resolves 'auto' to provider default model", () => {
-    const result = resolveModelRef("anthropic/auto");
-    expect(result.provider).toBe("anthropic");
-    expect(result.modelId).toBe(DEFAULT_PROVIDER_MODELS.anthropic);
-  });
-
-  test("uses AGENT_DEFAULT_PROVIDER for bare model ID", () => {
-    process.env.AGENT_DEFAULT_PROVIDER = "openai";
-    const result = resolveModelRef("gpt-4.1");
-    expect(result.provider).toBe("openai");
-    expect(result.modelId).toBe("gpt-4.1");
-  });
-
-  test("falls back to AGENT_DEFAULT_MODEL when rawModelRef is empty", () => {
-    process.env.AGENT_DEFAULT_MODEL = "anthropic/claude-sonnet-4-20250514";
-    const result = resolveModelRef("");
-    expect(result.provider).toBe("anthropic");
-    expect(result.modelId).toBe("claude-sonnet-4-20250514");
-  });
-
-  test("falls back to provider default when no model or AGENT_DEFAULT_MODEL", () => {
-    process.env.AGENT_DEFAULT_PROVIDER = "google";
-    const result = resolveModelRef("");
-    expect(result.provider).toBe("google");
-    expect(result.modelId).toBe(DEFAULT_PROVIDER_MODELS.google);
-  });
-
-  test("throws when no model can be determined", () => {
-    expect(() => resolveModelRef("")).toThrow("No model configured");
-  });
-
-  test("throws when bare model ID and no default provider", () => {
-    expect(() => resolveModelRef("some-model")).toThrow(
-      'No provider specified for model "some-model"'
-    );
-  });
-
-  test("trims whitespace from rawModelRef", () => {
-    const result = resolveModelRef("  anthropic/claude-sonnet-4-20250514  ");
-    expect(result.provider).toBe("anthropic");
-  });
-});
-
-describe("registerDynamicProvider", () => {
-  const testProviderId = `test-provider-${Date.now()}`;
-
-  afterEach(() => {
-    // Clean up test provider entries
-    delete DEFAULT_PROVIDER_BASE_URL_ENV[testProviderId];
-    delete DEFAULT_PROVIDER_MODELS[testProviderId];
-    delete PROVIDER_REGISTRY_ALIASES[testProviderId];
-  });
-
-  test("registers new provider with baseUrlEnvVar", () => {
-    registerDynamicProvider(testProviderId, {
-      baseUrlEnvVar: "TEST_BASE_URL",
-      sdkCompat: "openai",
-    });
-    expect(DEFAULT_PROVIDER_BASE_URL_ENV[testProviderId]).toBe("TEST_BASE_URL");
-  });
-
-  test("registers default model when provided", () => {
-    registerDynamicProvider(testProviderId, {
-      baseUrlEnvVar: "TEST_BASE_URL",
-      defaultModel: "test-model-v1",
-    });
-    expect(DEFAULT_PROVIDER_MODELS[testProviderId]).toBe("test-model-v1");
-  });
-
-  test("sets registry alias for openai-compatible providers", () => {
-    registerDynamicProvider(testProviderId, {
-      baseUrlEnvVar: "TEST_BASE_URL",
-      sdkCompat: "openai",
-    });
-    expect(PROVIDER_REGISTRY_ALIASES[testProviderId]).toBe("openai");
-  });
-
-  test("uses explicit registryAlias over sdkCompat", () => {
-    registerDynamicProvider(testProviderId, {
-      baseUrlEnvVar: "TEST_BASE_URL",
-      sdkCompat: "openai",
-      registryAlias: "custom",
-    });
-    expect(PROVIDER_REGISTRY_ALIASES[testProviderId]).toBe("custom");
-  });
-
-  test("skips already-registered provider", () => {
-    DEFAULT_PROVIDER_BASE_URL_ENV[testProviderId] = "EXISTING";
-    registerDynamicProvider(testProviderId, {
-      baseUrlEnvVar: "NEW_VALUE",
-    });
-    expect(DEFAULT_PROVIDER_BASE_URL_ENV[testProviderId]).toBe("EXISTING");
-  });
-
-  test("does not set alias when no sdkCompat or registryAlias", () => {
-    registerDynamicProvider(testProviderId, {
-      baseUrlEnvVar: "TEST_BASE_URL",
-    });
-    expect(PROVIDER_REGISTRY_ALIASES[testProviderId]).toBeUndefined();
-  });
-});
-
-describe("DEFAULT_PROVIDER_MODELS", () => {
-  test("contains expected providers", () => {
-    expect(DEFAULT_PROVIDER_MODELS.anthropic).toBeDefined();
-    expect(DEFAULT_PROVIDER_MODELS.openai).toBeDefined();
-    expect(DEFAULT_PROVIDER_MODELS.google).toBeDefined();
-  });
-});
-
-describe("DEFAULT_PROVIDER_BASE_URL_ENV", () => {
-  test("maps anthropic to ANTHROPIC_BASE_URL", () => {
-    expect(DEFAULT_PROVIDER_BASE_URL_ENV.anthropic).toBe("ANTHROPIC_BASE_URL");
-  });
-});

package/src/__tests__/processor.test.ts

@@ -1,225 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { OpenClawProgressProcessor } from "../openclaw/processor";
-
-function makeEvent(type: string, extra: Record<string, any> = {}): any {
-  return { type, ...extra };
-}
-
-function makeMessageUpdate(
-  assistantEventType: string,
-  delta = "",
-  role = "assistant"
-): any {
-  return makeEvent("message_update", {
-    message: { role },
-    assistantMessageEvent: { type: assistantEventType, delta },
-  });
-}
-
-describe("OpenClawProgressProcessor", () => {
-  test("processEvent returns false for non-assistant message_update", () => {
-    const p = new OpenClawProgressProcessor();
-    const event = makeMessageUpdate("text_delta", "hi", "user");
-    expect(p.processEvent(event)).toBe(false);
-  });
-
-  test("text_delta appends to output", () => {
-    const p = new OpenClawProgressProcessor();
-    p.processEvent(makeMessageUpdate("text_delta", "Hello"));
-    p.processEvent(makeMessageUpdate("text_delta", " world"));
-    expect(p.getDelta()).toBe("Hello world");
-  });
-
-  test("thinking_delta does not append by default", () => {
-    const p = new OpenClawProgressProcessor();
-    const result = p.processEvent(
-      makeMessageUpdate("thinking_delta", "thinking...")
-    );
-    expect(result).toBe(false);
-    expect(p.getDelta()).toBeNull();
-  });
-
-  test("thinking_delta appends when verbose", () => {
-    const p = new OpenClawProgressProcessor();
-    p.setVerboseLogging(true);
-    const result = p.processEvent(
-      makeMessageUpdate("thinking_delta", "thinking...")
-    );
-    expect(result).toBe(true);
-    expect(p.getDelta()).toContain("thinking...");
-  });
-
-  test("thinking_start/end output in verbose mode only", () => {
-    const p = new OpenClawProgressProcessor();
-    expect(p.processEvent(makeMessageUpdate("thinking_start"))).toBe(false);
-    expect(p.processEvent(makeMessageUpdate("thinking_end"))).toBe(false);
-
-    p.setVerboseLogging(true);
-    expect(p.processEvent(makeMessageUpdate("thinking_start"))).toBe(true);
-    expect(p.processEvent(makeMessageUpdate("thinking_end"))).toBe(true);
-  });
-
-  test("getCurrentThinking tracks thinking content", () => {
-    const p = new OpenClawProgressProcessor();
-    expect(p.getCurrentThinking()).toBeNull();
-    p.processEvent(makeMessageUpdate("thinking_delta", "step 1"));
-    expect(p.getCurrentThinking()).toBe("step 1");
-  });
-
-  test("message_end with error stores fatal error", () => {
-    const p = new OpenClawProgressProcessor();
-    const event = makeEvent("message_end", {
-      message: {
-        role: "assistant",
-        stopReason: "error",
-        errorMessage: "Something broke",
-      },
-    });
-    expect(p.processEvent(event)).toBe(false);
-    expect(p.consumeFatalErrorMessage()).toBe("Something broke");
-    // Consumed, so second call returns null
-    expect(p.consumeFatalErrorMessage()).toBeNull();
-  });
-
-  test("message_end extracts text when no streaming happened", () => {
-    const p = new OpenClawProgressProcessor();
-    const event = makeEvent("message_end", {
-      message: {
-        role: "assistant",
-        content: [{ type: "text", text: "Final answer" }],
-      },
-    });
-    expect(p.processEvent(event)).toBe(true);
-    expect(p.getDelta()).toContain("Final answer");
-  });
-
-  test("message_end skips extraction if text already streamed", () => {
-    const p = new OpenClawProgressProcessor();
-    // Stream some text first
-    p.processEvent(makeMessageUpdate("text_delta", "streamed"));
-    p.getDelta(); // consume
-    // Now message_end should skip
-    const event = makeEvent("message_end", {
-      message: {
-        role: "assistant",
-        content: [{ type: "text", text: "Final" }],
-      },
-    });
-    expect(p.processEvent(event)).toBe(false);
-  });
-
-  test("auto_compaction_start appends message", () => {
-    const p = new OpenClawProgressProcessor();
-    expect(p.processEvent(makeEvent("auto_compaction_start"))).toBe(true);
-    expect(p.getDelta()).toContain("Compacting context");
-  });
-
-  test("auto_compaction_end with aborted", () => {
-    const p = new OpenClawProgressProcessor();
-    expect(
-      p.processEvent(makeEvent("auto_compaction_end", { aborted: true }))
-    ).toBe(true);
-    expect(p.getDelta()).toContain("Compaction aborted");
-  });
-
-  test("auto_compaction_end with result", () => {
-    const p = new OpenClawProgressProcessor();
-    expect(
-      p.processEvent(makeEvent("auto_compaction_end", { result: {} }))
-    ).toBe(true);
-    expect(p.getDelta()).toContain("Context compacted");
-  });
-
-  test("auto_retry_start appends retry message", () => {
-    const p = new OpenClawProgressProcessor();
-    expect(
-      p.processEvent(
-        makeEvent("auto_retry_start", { attempt: 2, maxAttempts: 3 })
-      )
-    ).toBe(true);
-    expect(p.getDelta()).toContain("Retrying (attempt 2/3)");
-  });
-
-  test("auto_retry_end with failure appends error", () => {
-    const p = new OpenClawProgressProcessor();
-    expect(
-      p.processEvent(
-        makeEvent("auto_retry_end", {
-          success: false,
-          finalError: "timeout",
-        })
-      )
-    ).toBe(true);
-    expect(p.getDelta()).toContain("Retry failed: timeout");
-  });
-
-  test("auto_retry_end with success returns false", () => {
-    const p = new OpenClawProgressProcessor();
-    expect(p.processEvent(makeEvent("auto_retry_end", { success: true }))).toBe(
-      false
-    );
-  });
-
-  test("unknown event type returns false", () => {
-    const p = new OpenClawProgressProcessor();
-    expect(p.processEvent(makeEvent("unknown_event"))).toBe(false);
-  });
-});
-
-describe("getDelta", () => {
-  test("returns null when no content", () => {
-    const p = new OpenClawProgressProcessor();
-    expect(p.getDelta()).toBeNull();
-  });
-
-  test("returns null when content unchanged", () => {
-    const p = new OpenClawProgressProcessor();
-    p.processEvent(makeMessageUpdate("text_delta", "hello"));
-    p.getDelta(); // consume
-    expect(p.getDelta()).toBeNull();
-  });
-
-  test("returns only the new suffix on incremental append", () => {
-    const p = new OpenClawProgressProcessor();
-    p.processEvent(makeMessageUpdate("text_delta", "Hello"));
-    p.getDelta(); // consume "Hello"
-    p.processEvent(makeMessageUpdate("text_delta", " world"));
-    expect(p.getDelta()).toBe(" world");
-  });
-
-  test("returns full content on first call", () => {
-    const p = new OpenClawProgressProcessor();
-    p.processEvent(makeMessageUpdate("text_delta", "first"));
-    expect(p.getDelta()).toBe("first");
-  });
-});
-
-describe("finalResult lifecycle", () => {
-  test("set and get final result", () => {
-    const p = new OpenClawProgressProcessor();
-    expect(p.getFinalResult()).toBeNull();
-
-    p.setFinalResult({ text: "done", isFinal: true });
-    const result = p.getFinalResult();
-    expect(result).toEqual({ text: "done", isFinal: true });
-
-    // Consumed, so next call returns null
-    expect(p.getFinalResult()).toBeNull();
-  });
-});
-
-describe("reset", () => {
-  test("clears all state", () => {
-    const p = new OpenClawProgressProcessor();
-    p.processEvent(makeMessageUpdate("text_delta", "content"));
-    p.processEvent(makeMessageUpdate("thinking_delta", "thought"));
-    p.setFinalResult({ text: "done", isFinal: true });
-
-    p.reset();
-
-    expect(p.getDelta()).toBeNull();
-    expect(p.getCurrentThinking()).toBeNull();
-    expect(p.getFinalResult()).toBeNull();
-    expect(p.consumeFatalErrorMessage()).toBeNull();
-  });
-});

package/src/__tests__/setup.ts

@@ -1,109 +0,0 @@
-/**
- * Test setup and configuration for worker tests.
- *
- * Shared mocks live in @lobu/core fixtures.
- * This file re-exports them and adds worker-specific helpers.
- */
-
-import { afterAll, beforeAll } from "bun:test";
-import {
-  createWorkerConfig,
-  mockFetch as sharedMockFetch,
-} from "@lobu/core/testing";
-
-export {
-  createInstructionContext,
-  createWorkerConfig,
-  MockRedisClient,
-  mockFetch,
-} from "@lobu/core/testing";
-
-export const mockWorkerConfig = createWorkerConfig();
-
-// Mock environment variables for testing
-const mockEnvVars: Record<string, string> = {
-  DISPATCHER_URL: "https://test-dispatcher.example.com",
-  WORKER_TOKEN: "test-worker-token-123",
-  CONVERSATION_ID: "1234567890.123456",
-  WORKER_SESSION_KEY: "test-session-key",
-  WORKER_USER_ID: "U1234567890",
-  WORKER_CHANNEL_ID: "C1234567890",
-  WORKER_USER_PROMPT: Buffer.from("Test user prompt").toString("base64"),
-  WORKER_RESPONSE_CHANNEL: "C1234567890",
-  WORKER_RESPONSE_TS: "1234567890.123457",
-  WORKER_CLAUDE_OPTIONS: JSON.stringify({
-    model: "claude-sonnet-4-20250514",
-    max_tokens: 8192,
-  }),
-  WORKER_TEAM_ID: "T1234567890",
-  WORKER_WORKSPACE_BASE_DIRECTORY: "/tmp/test-workspace",
-};
-
-export class TestHelpers {
-  static mockFetch(responses?: Record<string, any>): () => void {
-    return sharedMockFetch(responses);
-  }
-
-  static createMockProgressUpdate(
-    type: "output" | "completion" | "error",
-    data: any
-  ) {
-    return { type, data, timestamp: Date.now() };
-  }
-
-  static async delay(ms: number): Promise<void> {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-  }
-
-  static mockEventSource() {
-    class MockEventSource {
-      url: string;
-      readyState = 1;
-      onopen: ((event: Event) => void) | null = null;
-      onmessage: ((event: MessageEvent) => void) | null = null;
-      onerror: ((event: Event) => void) | null = null;
-
-      constructor(url: string) {
-        this.url = url;
-        setTimeout(() => {
-          if (this.onopen) this.onopen(new Event("open"));
-        }, 10);
-      }
-
-      close() {
-        this.readyState = 2;
-      }
-
-      simulateMessage(data: any) {
-        if (this.onmessage) {
-          this.onmessage(
-            new MessageEvent("message", { data: JSON.stringify(data) })
-          );
-        }
-      }
-
-      simulateError() {
-        if (this.onerror) this.onerror(new Event("error"));
-      }
-    }
-
-    const originalEventSource = globalThis.EventSource;
-    globalThis.EventSource = MockEventSource as any;
-    return () => {
-      globalThis.EventSource = originalEventSource;
-    };
-  }
-}
-
-// Global test setup
-beforeAll(() => {
-  for (const [key, value] of Object.entries(mockEnvVars)) {
-    process.env[key] = value;
-  }
-});
-
-afterAll(() => {
-  for (const key of Object.keys(mockEnvVars)) {
-    delete process.env[key];
-  }
-});