@lobu/worker 6.0.1 → 7.0.0

package/src/__tests__/message-batcher.test.ts

@@ -0,0 +1,247 @@
+/**
+ * Hardening tests for MessageBatcher.
+ *
+ * Covers:
+ * - First message is processed immediately (no batch window)
+ * - Subsequent messages enter the batch window
+ * - Messages queued during processing are handled after the current batch
+ * - stop() cancels a pending batch timer
+ * - Messages are sorted by timestamp before delivery
+ * - onBatchReady receives combined messages in order
+ * - getPendingCount and isCurrentlyProcessing visibility
+ * - Error in onBatchReady is caught, isProcessing is reset to false
+ */
+
+import { describe, expect, test } from "bun:test";
+import { MessageBatcher } from "../gateway/message-batcher";
+import type { QueuedMessage } from "../gateway/types";
+
+function makeMsg(
+  messageId: string,
+  messageText = "hello",
+  timestamp = Date.now()
+): QueuedMessage {
+  return {
+    timestamp,
+    payload: {
+      botId: "bot",
+      userId: "user-1",
+      agentId: "agent-1",
+      conversationId: "conv-1",
+      platform: "api",
+      channelId: "chan-1",
+      messageId,
+      messageText,
+      platformMetadata: {},
+      agentOptions: {},
+    },
+  };
+}
+
+// ---------------------------------------------------------------------------
+// First message — immediate processing
+// ---------------------------------------------------------------------------
+
+describe("MessageBatcher — first message processed immediately", () => {
+  test("onBatchReady called synchronously (within the addMessage await) for first message", async () => {
+    const processed: string[][] = [];
+    const batcher = new MessageBatcher({
+      onBatchReady: async (msgs) => {
+        processed.push(msgs.map((m) => m.payload.messageId));
+      },
+      batchWindowMs: 5000, // long window — should not matter for first message
+    });
+
+    await batcher.addMessage(makeMsg("msg-1", "hello", 1000));
+    expect(processed).toHaveLength(1);
+    expect(processed[0]).toEqual(["msg-1"]);
+  });
+
+  test("getPendingCount is 0 after first message is processed", async () => {
+    const batcher = new MessageBatcher({
+      onBatchReady: async () => undefined,
+    });
+    await batcher.addMessage(makeMsg("msg-1"));
+    expect(batcher.getPendingCount()).toBe(0);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Messages during processing — queued for next batch
+// ---------------------------------------------------------------------------
+
+describe("MessageBatcher — message queued during processing", () => {
+  test("message added while onBatchReady is running is queued and processed after", async () => {
+    const batches: string[][] = [];
+    let resolveBatch: (() => void) | null = null;
+
+    const batcher = new MessageBatcher({
+      batchWindowMs: 50,
+      onBatchReady: async (msgs) => {
+        batches.push(msgs.map((m) => m.payload.messageId));
+        if (batches.length === 1) {
+          // Signal that first batch is about to complete; test adds a message now
+          await new Promise<void>((r) => {
+            resolveBatch = r;
+          });
+        }
+      },
+    });
+
+    // Start first batch
+    const firstBatch = batcher.addMessage(makeMsg("msg-1", "first", 1));
+    // Wait until onBatchReady is blocking on the promise
+    await new Promise((r) => setTimeout(r, 5));
+
+    // Add message while processing — should queue for next batch
+    batcher.addMessage(makeMsg("msg-2", "second", 2)).catch(() => undefined);
+    expect(batcher.getPendingCount()).toBe(1);
+
+    // Release the first onBatchReady
+    resolveBatch?.();
+    await firstBatch;
+
+    // Wait for the second batch timer to fire
+    await new Promise((r) => setTimeout(r, 200));
+
+    expect(batches).toHaveLength(2);
+    expect(batches[0]).toEqual(["msg-1"]);
+    expect(batches[1]).toEqual(["msg-2"]);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Batch window — messages collected and sorted
+// ---------------------------------------------------------------------------
+
+describe("MessageBatcher — batch window collects messages by timestamp", () => {
+  test("two messages added within batch window arrive in timestamp order", async () => {
+    const batches: QueuedMessage[][] = [];
+
+    const batcher = new MessageBatcher({
+      batchWindowMs: 50,
+      onBatchReady: async (msgs) => {
+        batches.push(msgs);
+      },
+    });
+
+    // First message → triggers immediate processing (consumes initial batch)
+    await batcher.addMessage(makeMsg("msg-1", "first", 1));
+
+    // Now send two messages quickly within the batch window
+    await batcher.addMessage(makeMsg("msg-3", "third", 300));
+    await batcher.addMessage(makeMsg("msg-2", "second", 200));
+
+    // Wait for the batch window to fire
+    await new Promise((r) => setTimeout(r, 200));
+
+    expect(batches).toHaveLength(2);
+    // Second batch should contain both messages sorted by timestamp
+    const secondBatch = batches[1];
+    expect(secondBatch).toHaveLength(2);
+    expect(secondBatch?.[0]?.payload.messageId).toBe("msg-2"); // ts=200 < ts=300
+    expect(secondBatch?.[1]?.payload.messageId).toBe("msg-3");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// stop() cancels pending timer
+// ---------------------------------------------------------------------------
+
+describe("MessageBatcher — stop()", () => {
+  test("stop() after first message prevents queued timer from firing", async () => {
+    const processed: string[][] = [];
+    const batcher = new MessageBatcher({
+      batchWindowMs: 50,
+      onBatchReady: async (msgs) => {
+        processed.push(msgs.map((m) => m.payload.messageId));
+      },
+    });
+
+    // First message processed immediately
+    await batcher.addMessage(makeMsg("msg-1", "first", 1));
+
+    // Add a second message which starts the batch timer
+    await batcher.addMessage(makeMsg("msg-2", "second", 2));
+    // Stop before the timer fires
+    batcher.stop();
+
+    // Wait longer than the batch window
+    await new Promise((r) => setTimeout(r, 200));
+
+    // Only the first batch should have been delivered
+    expect(processed).toHaveLength(1);
+    expect(processed[0]).toEqual(["msg-1"]);
+  });
+
+  test("getPendingCount remains 1 after stop() if message was queued", async () => {
+    const batcher = new MessageBatcher({
+      batchWindowMs: 50,
+      onBatchReady: async () => undefined,
+    });
+
+    await batcher.addMessage(makeMsg("msg-1", "first", 1));
+    await batcher.addMessage(makeMsg("msg-2", "second", 2));
+
+    batcher.stop();
+
+    // The timer was cleared; the queued message is still in the queue
+    expect(batcher.getPendingCount()).toBe(1);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// isCurrentlyProcessing visibility
+// ---------------------------------------------------------------------------
+
+describe("MessageBatcher — isCurrentlyProcessing", () => {
+  test("isCurrentlyProcessing is true during onBatchReady and false after", async () => {
+    const states: boolean[] = [];
+    let markProcessingDone: (() => void) | null = null;
+
+    const batcher = new MessageBatcher({
+      onBatchReady: async () => {
+        states.push(batcher.isCurrentlyProcessing());
+        await new Promise<void>((r) => {
+          markProcessingDone = r;
+        });
+      },
+    });
+
+    const p = batcher.addMessage(makeMsg("msg-1", "hello", 1));
+    // Give the event loop a tick so onBatchReady starts
+    await new Promise((r) => setTimeout(r, 5));
+
+    expect(batcher.isCurrentlyProcessing()).toBe(true);
+    markProcessingDone?.();
+    await p;
+    expect(batcher.isCurrentlyProcessing()).toBe(false);
+    expect(states).toContain(true);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Error in onBatchReady resets isProcessing
+// ---------------------------------------------------------------------------
+
+describe("MessageBatcher — error resilience", () => {
+  test("error thrown in onBatchReady resets isProcessing to false", async () => {
+    const batcher = new MessageBatcher({
+      onBatchReady: async () => {
+        throw new Error("batch processing failed");
+      },
+    });
+
+    // addMessage is fire-and-forget via setTimeout for subsequent batches,
+    // but first message is awaited synchronously — error is swallowed in the
+    // private processBatch() try/finally.
+    try {
+      await batcher.addMessage(makeMsg("msg-1", "hello", 1));
+    } catch {
+      // may or may not propagate depending on implementation path
+    }
+
+    // After any error path, isProcessing must be false
+    expect(batcher.isCurrentlyProcessing()).toBe(false);
+  });
+});

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

@@ -0,0 +1,197 @@
+/**
+ * Hardening tests for model-resolver edge cases.
+ *
+ * Covers:
+ * - resolveModelRef with multi-segment model IDs (provider/org/model)
+ * - "auto" resolving to provider default
+ * - Unknown provider in "provider/model" format still parsed (no registry check)
+ * - resolveModelRef with null/undefined input (type boundary)
+ * - registerDynamicProvider idempotency and alias precedence
+ * - DEFAULT_PROVIDER_MODELS covers the known provider set
+ * - No real credentials in resolver output
+ */
+
+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";
+
+// Unique-enough prefix to avoid clashing with parallel test workers
+const PREFIX = `test-${process.pid}-${Date.now()}`;
+
+describe("resolveModelRef — edge cases", () => {
+  let origDefaultModel: string | undefined;
+  let origDefaultProvider: string | undefined;
+
+  beforeEach(() => {
+    origDefaultModel = process.env.AGENT_DEFAULT_MODEL;
+    origDefaultProvider = process.env.AGENT_DEFAULT_PROVIDER;
+    delete process.env.AGENT_DEFAULT_MODEL;
+    delete process.env.AGENT_DEFAULT_PROVIDER;
+  });
+
+  afterEach(() => {
+    if (origDefaultModel !== undefined)
+      process.env.AGENT_DEFAULT_MODEL = origDefaultModel;
+    else delete process.env.AGENT_DEFAULT_MODEL;
+
+    if (origDefaultProvider !== undefined)
+      process.env.AGENT_DEFAULT_PROVIDER = origDefaultProvider;
+    else delete process.env.AGENT_DEFAULT_PROVIDER;
+  });
+
+  test("multi-segment model: nvidia/org/model-id", () => {
+    const result = resolveModelRef("nvidia/moonshotai/kimi-k2.5");
+    expect(result.provider).toBe("nvidia");
+    expect(result.modelId).toBe("moonshotai/kimi-k2.5");
+  });
+
+  test("three-part openai-compat path", () => {
+    const result = resolveModelRef("openai-codex/gpt-5.1-codex-max");
+    expect(result.provider).toBe("openai-codex");
+    expect(result.modelId).toBe("gpt-5.1-codex-max");
+  });
+
+  test("unknown provider in provider/model format is returned verbatim", () => {
+    // resolveModelRef does NOT validate against a registry — it just parses
+    const result = resolveModelRef("future-provider/some-model-v99");
+    expect(result.provider).toBe("future-provider");
+    expect(result.modelId).toBe("some-model-v99");
+  });
+
+  test("auto model for unknown provider returns the raw 'auto' string", () => {
+    // If DEFAULT_PROVIDER_MODELS doesn't have the provider, auto stays as-is
+    const result = resolveModelRef("unknown-provider-xyz/auto");
+    expect(result.provider).toBe("unknown-provider-xyz");
+    expect(result.modelId).toBe("auto");
+  });
+
+  test("auto model for anthropic resolves to non-empty string", () => {
+    const result = resolveModelRef("anthropic/auto");
+    expect(result.provider).toBe("anthropic");
+    expect(result.modelId).toBeTruthy();
+    expect(result.modelId).not.toBe("auto");
+  });
+
+  test("overrides.defaultModel takes priority over env var", () => {
+    process.env.AGENT_DEFAULT_MODEL = "google/gemini-2.5-pro";
+    const result = resolveModelRef("", {
+      defaultModel: "anthropic/claude-sonnet-4-20250514",
+    });
+    expect(result.provider).toBe("anthropic");
+    expect(result.modelId).toBe("claude-sonnet-4-20250514");
+  });
+
+  test("overrides.defaultProvider takes priority over env var", () => {
+    process.env.AGENT_DEFAULT_PROVIDER = "google";
+    const result = resolveModelRef("some-model", {
+      defaultProvider: "openai",
+    });
+    expect(result.provider).toBe("openai");
+    expect(result.modelId).toBe("some-model");
+  });
+
+  test("whitespace-only rawModelRef falls back to env vars", () => {
+    process.env.AGENT_DEFAULT_MODEL = "openai/gpt-4.1";
+    const result = resolveModelRef("   ");
+    expect(result.provider).toBe("openai");
+    expect(result.modelId).toBe("gpt-4.1");
+  });
+
+  test("throws with descriptive message when no provider context exists", () => {
+    // Neither env var nor override
+    expect(() => resolveModelRef("just-a-model-name")).toThrow(
+      'No provider specified for model "just-a-model-name"'
+    );
+  });
+
+  test("throws when everything is empty and no defaults", () => {
+    expect(() => resolveModelRef("")).toThrow("No model configured");
+  });
+});
+
+describe("resolveModelRef — does not leak secrets", () => {
+  test("model ID containing lobu_secret placeholder is passed through unchanged", () => {
+    // Unlikely in practice but the resolver must not strip or transform it
+    const secretRef = "lobu_secret_abc";
+    const result = resolveModelRef(`test-provider/${secretRef}`);
+    expect(result.modelId).toBe(secretRef);
+  });
+});
+
+describe("registerDynamicProvider — idempotency and precedence", () => {
+  const id = `${PREFIX}-dynamic`;
+
+  afterEach(() => {
+    delete DEFAULT_PROVIDER_BASE_URL_ENV[id];
+    delete DEFAULT_PROVIDER_MODELS[id];
+    delete PROVIDER_REGISTRY_ALIASES[id];
+  });
+
+  test("registering twice keeps first baseUrlEnvVar", () => {
+    registerDynamicProvider(id, { baseUrlEnvVar: "FIRST_URL" });
+    registerDynamicProvider(id, { baseUrlEnvVar: "SECOND_URL" });
+    expect(DEFAULT_PROVIDER_BASE_URL_ENV[id]).toBe("FIRST_URL");
+  });
+
+  test("registering twice keeps first default model", () => {
+    registerDynamicProvider(id, {
+      baseUrlEnvVar: "URL",
+      defaultModel: "model-v1",
+    });
+    registerDynamicProvider(id, {
+      baseUrlEnvVar: "URL",
+      defaultModel: "model-v2",
+    });
+    expect(DEFAULT_PROVIDER_MODELS[id]).toBe("model-v1");
+  });
+
+  test("explicit registryAlias is preferred over sdkCompat alias", () => {
+    registerDynamicProvider(id, {
+      baseUrlEnvVar: "URL",
+      sdkCompat: "openai",
+      registryAlias: "my-alias",
+    });
+    expect(PROVIDER_REGISTRY_ALIASES[id]).toBe("my-alias");
+  });
+
+  test("no registryAlias entry when neither sdkCompat nor explicit alias given", () => {
+    registerDynamicProvider(id, { baseUrlEnvVar: "URL" });
+    expect(PROVIDER_REGISTRY_ALIASES[id]).toBeUndefined();
+  });
+
+  test("registered dynamic provider is resolvable via resolveModelRef", () => {
+    registerDynamicProvider(id, {
+      baseUrlEnvVar: "MY_BASE_URL",
+      defaultModel: "dynamic-default",
+    });
+    const result = resolveModelRef("", { defaultProvider: id });
+    expect(result.provider).toBe(id);
+    expect(result.modelId).toBe("dynamic-default");
+  });
+});
+
+describe("DEFAULT_PROVIDER_MODELS completeness", () => {
+  const EXPECTED_PROVIDERS = [
+    "anthropic",
+    "openai",
+    "openai-codex",
+    "google",
+    "nvidia",
+    "z-ai",
+  ];
+
+  for (const provider of EXPECTED_PROVIDERS) {
+    test(`provider "${provider}" has a non-empty default model`, () => {
+      expect(DEFAULT_PROVIDER_MODELS[provider]).toBeTruthy();
+    });
+
+    test(`provider "${provider}" has a base URL env var mapping`, () => {
+      expect(DEFAULT_PROVIDER_BASE_URL_ENV[provider]).toBeTruthy();
+    });
+  }
+});

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

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