bereach-openclaw 1.5.11 → 1.6.1

package/node_modules/@bereach/tools/package.json

@@ -16,11 +16,16 @@
     "./cost-estimation": "./src/cost-estimation.ts",
     "./llm-errors": "./src/llm-errors.ts"
   },
-  "files": ["src/"],
+  "files": [
+    "src/"
+  ],
   "scripts": {
-    "typecheck": "tsc --noEmit"
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest"
   },
   "devDependencies": {
-    "typescript": "^6.0.2"
+    "typescript": "^6.0.2",
+    "vitest": "^4.1.4"
   }
 }

package/node_modules/@bereach/tools/src/__tests__/cost-estimation.test.ts

@@ -0,0 +1,198 @@
+/**
+ * Tests for LLM cost estimation functions.
+ * Pure function tests - no mocking.
+ */
+
+import { describe, it, expect } from "vitest";
+import {
+  estimateTaskCost,
+  extractTokenUsage,
+  MODEL_PRICING,
+} from "../cost-estimation.js";
+
+// ─── MODEL_PRICING ─────────────────────────────────────────────────
+
+describe("MODEL_PRICING", () => {
+  it("has haiku, sonnet, flash, pro models", () => {
+    expect(MODEL_PRICING).toHaveProperty("haiku");
+    expect(MODEL_PRICING).toHaveProperty("sonnet");
+    expect(MODEL_PRICING).toHaveProperty("flash");
+    expect(MODEL_PRICING).toHaveProperty("pro");
+  });
+
+  it("haiku is cheaper than sonnet", () => {
+    expect(MODEL_PRICING.haiku.input).toBeLessThan(MODEL_PRICING.sonnet.input);
+    expect(MODEL_PRICING.haiku.output).toBeLessThan(MODEL_PRICING.sonnet.output);
+  });
+
+  it("all models have cacheRead < input pricing", () => {
+    for (const [, pricing] of Object.entries(MODEL_PRICING)) {
+      expect(pricing.cacheRead).toBeLessThan(pricing.input);
+    }
+  });
+});
+
+// ─── estimateTaskCost ──────────────────────────────────────────────
+
+describe("estimateTaskCost", () => {
+  it("returns 0 for zero tokens", () => {
+    expect(estimateTaskCost(0, 0, 0)).toBe(0);
+  });
+
+  it("defaults to haiku pricing when no model provided", () => {
+    const cost = estimateTaskCost(1000, 500, 0);
+    // haiku: 1000 * 1.0/1M + 500 * 5.0/1M = 0.001 + 0.0025 = 0.0035
+    expect(cost).toBeCloseTo(0.0035, 6);
+  });
+
+  it("matches haiku for claude-3-5-haiku model slug", () => {
+    const cost = estimateTaskCost(1000, 500, 0, "claude-3-5-haiku-20241022");
+    expect(cost).toBeCloseTo(0.0035, 6);
+  });
+
+  it("matches sonnet for claude-sonnet-4-20250514 model slug", () => {
+    const cost = estimateTaskCost(1000, 500, 0, "claude-sonnet-4-20250514");
+    // sonnet: 1000 * 3.0/1M + 500 * 15.0/1M = 0.003 + 0.0075 = 0.0105
+    expect(cost).toBeCloseTo(0.0105, 6);
+  });
+
+  it("subtracts cached tokens from input cost", () => {
+    // 1000 input, 500 output, 800 cached
+    // uncached = max(0, 1000-800) = 200
+    // haiku: 200 * 1.0/1M + 800 * 0.1/1M + 500 * 5.0/1M = 0.0002 + 0.00008 + 0.0025 = 0.00278
+    const cost = estimateTaskCost(1000, 500, 800);
+    expect(cost).toBeCloseTo(0.00278, 6);
+  });
+
+  it("handles cacheRead > inputTokens (uncached = 0)", () => {
+    // edge case: more cached reads than input (prompt caching overlap)
+    const cost = estimateTaskCost(500, 100, 800);
+    // uncached = max(0, 500-800) = 0
+    // haiku: 0 + 800 * 0.1/1M + 100 * 5.0/1M = 0 + 0.00008 + 0.0005 = 0.00058
+    expect(cost).toBeCloseTo(0.00058, 6);
+  });
+
+  it("includes cache write cost", () => {
+    // haiku cacheWrite = 1.25/1M
+    const costWithout = estimateTaskCost(1000, 500, 0, "haiku", 0);
+    const costWith = estimateTaskCost(1000, 500, 0, "haiku", 10000);
+    expect(costWith).toBeGreaterThan(costWithout);
+    expect(costWith - costWithout).toBeCloseTo(10000 * 1.25 / 1_000_000, 8);
+  });
+
+  it("defaults to haiku for null model slug", () => {
+    expect(estimateTaskCost(1000, 500, 0, null)).toBeCloseTo(0.0035, 6);
+  });
+
+  it("defaults to haiku for undefined model slug", () => {
+    expect(estimateTaskCost(1000, 500, 0, undefined)).toBeCloseTo(0.0035, 6);
+  });
+
+  it("defaults to haiku for unknown model slug", () => {
+    expect(estimateTaskCost(1000, 500, 0, "gpt-4o-mini")).toBeCloseTo(0.0035, 6);
+  });
+
+  it("matches flash for gemini-flash slug", () => {
+    const cost = estimateTaskCost(1000, 500, 0, "gemini-2.0-flash");
+    // flash: 1000 * 0.3/1M + 500 * 2.5/1M = 0.0003 + 0.00125 = 0.00155
+    expect(cost).toBeCloseTo(0.00155, 6);
+  });
+});
+
+// ─── extractTokenUsage ─────────────────────────────────────────────
+
+describe("extractTokenUsage", () => {
+  it("returns null when input and output are both 0", () => {
+    expect(extractTokenUsage({})).toBeNull();
+    expect(extractTokenUsage({ agentMeta: {} })).toBeNull();
+  });
+
+  it("extracts from agentMeta.lastCallUsage (camelCase)", () => {
+    const result = extractTokenUsage({
+      agentMeta: {
+        lastCallUsage: { input: 1000, output: 500 },
+        model: "claude-3-5-haiku",
+      },
+    });
+    expect(result).toEqual({
+      usage: { inputTokens: 1000, outputTokens: 500 },
+      model: "claude-3-5-haiku",
+    });
+  });
+
+  it("extracts from agentMeta.lastCallUsage (snake_case)", () => {
+    const result = extractTokenUsage({
+      agentMeta: {
+        lastCallUsage: { input_tokens: 2000, output_tokens: 800 },
+      },
+    });
+    expect(result?.usage.inputTokens).toBe(2000);
+    expect(result?.usage.outputTokens).toBe(800);
+  });
+
+  it("extracts from meta.cost path", () => {
+    const result = extractTokenUsage({
+      cost: { inputTokens: 500, outputTokens: 200 },
+    });
+    expect(result?.usage.inputTokens).toBe(500);
+    expect(result?.usage.outputTokens).toBe(200);
+  });
+
+  it("extracts from meta.usage path", () => {
+    const result = extractTokenUsage({
+      usage: { input: 300, output: 150 },
+    });
+    expect(result?.usage.inputTokens).toBe(300);
+    expect(result?.usage.outputTokens).toBe(150);
+  });
+
+  it("includes cacheRead when present", () => {
+    const result = extractTokenUsage({
+      agentMeta: {
+        lastCallUsage: { input: 1000, output: 500, cacheRead: 800 },
+      },
+    });
+    expect(result?.usage.cacheReadTokens).toBe(800);
+  });
+
+  it("omits cacheRead when 0", () => {
+    const result = extractTokenUsage({
+      agentMeta: {
+        lastCallUsage: { input: 1000, output: 500, cacheRead: 0 },
+      },
+    });
+    expect(result?.usage.cacheReadTokens).toBeUndefined();
+  });
+
+  it("includes cacheWrite when present", () => {
+    const result = extractTokenUsage({
+      agentMeta: {
+        lastCallUsage: { input: 1000, output: 500, cacheWrite: 200 },
+      },
+    });
+    expect(result?.usage.cacheWriteTokens).toBe(200);
+  });
+
+  it("resolves model from agentMeta first, then meta", () => {
+    const result = extractTokenUsage({
+      agentMeta: { lastCallUsage: { input: 1, output: 1 }, model: "from-agent" },
+      model: "from-meta",
+    });
+    expect(result?.model).toBe("from-agent");
+  });
+
+  it("falls back to meta.model when agentMeta.model missing", () => {
+    const result = extractTokenUsage({
+      agentMeta: { lastCallUsage: { input: 1, output: 1 } },
+      model: "from-meta",
+    });
+    expect(result?.model).toBe("from-meta");
+  });
+
+  it("handles snake_case cache fields", () => {
+    const result = extractTokenUsage({
+      usage: { input: 1000, output: 500, cache_read_input_tokens: 300 },
+    });
+    expect(result?.usage.cacheReadTokens).toBe(300);
+  });
+});

package/node_modules/@bereach/tools/src/__tests__/enforcement-helpers.test.ts

@@ -0,0 +1,202 @@
+/**
+ * Tests for enforcement helper functions and constants.
+ * Pure function tests - no mocking.
+ */
+
+import { describe, it, expect } from "vitest";
+import {
+  ACTION_MAP,
+  trackBlock,
+  clearBlock,
+  blockMsg,
+} from "../enforcement-helpers.js";
+import {
+  createSessionState,
+  READ_TOOLS,
+  WRITE_TOOLS,
+  FREE_TOOLS,
+  PACED_FREE_TOOLS,
+} from "../enforcement-types.js";
+
+// ─── ACTION_MAP ────────────────────────────────────────────────────
+
+describe("ACTION_MAP", () => {
+  it("maps visit_profile to profile_visit", () => {
+    expect(ACTION_MAP.bereach_visit_profile).toBe("profile_visit");
+  });
+
+  it("maps bulk_visit_profiles to profile_visit", () => {
+    expect(ACTION_MAP.bereach_bulk_visit_profiles).toBe("profile_visit");
+  });
+
+  it("maps connect_profile to connection_request", () => {
+    expect(ACTION_MAP.bereach_connect_profile).toBe("connection_request");
+  });
+
+  it("maps send_message to message", () => {
+    expect(ACTION_MAP.bereach_send_message).toBe("message");
+  });
+
+  it("maps accept_invitation to accept_invitation", () => {
+    expect(ACTION_MAP.bereach_accept_invitation).toBe("accept_invitation");
+  });
+
+  it("maps all scraping tools to scraping", () => {
+    const scrapingTools = [
+      "bereach_unified_search",
+      "bereach_search_sales_nav",
+      "bereach_collect_likes",
+      "bereach_collect_comments",
+      "bereach_collect_posts",
+    ];
+    for (const tool of scrapingTools) {
+      expect(ACTION_MAP[tool]).toBe("scraping");
+    }
+  });
+
+  it("returns undefined for free/contact tools", () => {
+    expect(ACTION_MAP.bereach_contacts_search).toBeUndefined();
+    expect(ACTION_MAP.bereach_context_set).toBeUndefined();
+    expect(ACTION_MAP.bereach_list_tasks).toBeUndefined();
+  });
+});
+
+// ─── trackBlock / clearBlock ───────────────────────────────────────
+
+describe("trackBlock", () => {
+  it("returns 1 on first block", () => {
+    const state = createSessionState();
+    expect(trackBlock(state, "bereach_send_message", "credits")).toBe(1);
+  });
+
+  it("increments on repeated blocks", () => {
+    const state = createSessionState();
+    trackBlock(state, "bereach_send_message", "credits");
+    trackBlock(state, "bereach_send_message", "credits");
+    expect(trackBlock(state, "bereach_send_message", "credits")).toBe(3);
+  });
+
+  it("tracks different tools independently", () => {
+    const state = createSessionState();
+    trackBlock(state, "bereach_send_message", "credits");
+    trackBlock(state, "bereach_send_message", "credits");
+    expect(trackBlock(state, "bereach_visit_profile", "credits")).toBe(1);
+  });
+
+  it("tracks different reasons independently", () => {
+    const state = createSessionState();
+    trackBlock(state, "bereach_send_message", "credits");
+    expect(trackBlock(state, "bereach_send_message", "rate_limit")).toBe(1);
+  });
+});
+
+describe("clearBlock", () => {
+  it("clears all block reasons for a tool", () => {
+    const state = createSessionState();
+    trackBlock(state, "bereach_send_message", "credits");
+    trackBlock(state, "bereach_send_message", "rate_limit");
+    clearBlock(state, "bereach_send_message");
+    // After clearing, next block should return 1 again
+    expect(trackBlock(state, "bereach_send_message", "credits")).toBe(1);
+  });
+
+  it("does not affect other tools", () => {
+    const state = createSessionState();
+    trackBlock(state, "bereach_send_message", "credits");
+    trackBlock(state, "bereach_visit_profile", "credits");
+    clearBlock(state, "bereach_send_message");
+    expect(trackBlock(state, "bereach_visit_profile", "credits")).toBe(2);
+  });
+});
+
+// ─── blockMsg ──────────────────────────────────────────────────────
+
+describe("blockMsg", () => {
+  it("returns BLOCKED message for count < 3", () => {
+    const msg = blockMsg(1, "bereach_send_message", "Credit limit", "Upgrade needed");
+    expect(msg).toMatch(/^BLOCKED:/);
+    expect(msg).toContain("Credit limit");
+  });
+
+  it("returns STOP RETRYING message for count >= 3", () => {
+    const msg = blockMsg(3, "bereach_send_message", "Credit limit", "Stop all work");
+    expect(msg).toMatch(/^STOP RETRYING:/);
+    expect(msg).toContain("Stop all work");
+  });
+
+  it("escalates at exactly 3", () => {
+    expect(blockMsg(2, "tool", "reason", "d1")).toMatch(/^BLOCKED:/);
+    expect(blockMsg(3, "tool", "reason", "d2")).toMatch(/^STOP RETRYING:/);
+  });
+});
+
+// ─── Tool categories: no overlap ───────────────────────────────────
+
+describe("tool category sets", () => {
+  it("READ_TOOLS and WRITE_TOOLS do not overlap", () => {
+    for (const tool of READ_TOOLS) {
+      expect(WRITE_TOOLS.has(tool)).toBe(false);
+    }
+  });
+
+  it("FREE_TOOLS and READ_TOOLS do not overlap", () => {
+    for (const tool of FREE_TOOLS) {
+      expect(READ_TOOLS.has(tool)).toBe(false);
+    }
+  });
+
+  it("FREE_TOOLS and WRITE_TOOLS do not overlap", () => {
+    for (const tool of FREE_TOOLS) {
+      expect(WRITE_TOOLS.has(tool)).toBe(false);
+    }
+  });
+
+  it("PACED_FREE_TOOLS and FREE_TOOLS do not overlap", () => {
+    for (const tool of PACED_FREE_TOOLS) {
+      expect(FREE_TOOLS.has(tool)).toBe(false);
+    }
+  });
+
+  it("new monitoring tools are in FREE_TOOLS", () => {
+    expect(FREE_TOOLS.has("bereach_list_tasks")).toBe(true);
+    expect(FREE_TOOLS.has("bereach_cancel_task")).toBe(true);
+    expect(FREE_TOOLS.has("bereach_cancel_chain")).toBe(true);
+    expect(FREE_TOOLS.has("bereach_campaign_health")).toBe(true);
+  });
+
+  it.each([
+    "bereach_events_feed",
+    "bereach_review_drafts",
+    "bereach_global_activities",
+    "bereach_bulk_visit_batch_status",
+  ])("'%s' is in FREE_TOOLS (read-only management tool)", (tool) => {
+    expect(FREE_TOOLS.has(tool)).toBe(true);
+  });
+});
+
+// ─── SessionState initialization ───────────────────────────────────
+
+describe("createSessionState", () => {
+  it("initializes all required fields", () => {
+    const state = createSessionState();
+    expect(state.visitedProfiles).toBeInstanceOf(Set);
+    expect(state.dmHistoryChecked).toBeInstanceOf(Set);
+    expect(state.targetedContacts).toBeInstanceOf(Set);
+    expect(state.blockedReasons).toBeInstanceOf(Map);
+    expect(state.visitCount).toBe(0);
+    expect(state.creditsUsedThisSession).toBe(0);
+    expect(state.toolCallCount).toBe(0);
+    expect(state.lastDmSentAt).toBe(0);
+    expect(state.postsThisSession).toBe(0);
+    expect(state.currentTaskMode).toBeNull();
+  });
+
+  it("creates independent instances (no shared state)", () => {
+    const s1 = createSessionState();
+    const s2 = createSessionState();
+    s1.visitCount = 10;
+    s1.visitedProfiles.add("test");
+    expect(s2.visitCount).toBe(0);
+    expect(s2.visitedProfiles.size).toBe(0);
+  });
+});

package/node_modules/@bereach/tools/src/__tests__/enforcement-rules.test.ts

@@ -0,0 +1,179 @@
+/**
+ * Tests for shared enforcement rules used by both MCP and OpenClaw.
+ * Pure function tests - no mocking.
+ */
+
+import { describe, it, expect } from "vitest";
+import {
+  dmCampaignGuard,
+  contextScopeGuard,
+  warmupActionGuard,
+  creditCapGuard,
+} from "../enforcement-rules.js";
+import type { TaskModeInfo } from "../enforcement-types.js";
+
+// ─── Factory helpers ───────────────────────────────────────────────
+
+function taskMode(overrides: Partial<TaskModeInfo> = {}): TaskModeInfo {
+  return {
+    taskType: "outreach-batch",
+    taskId: "task-1",
+    campaignId: "camp-1",
+    maxCredits: 30,
+    ...overrides,
+  };
+}
+
+// ─── dmCampaignGuard ───────────────────────────────────────────────
+
+describe("dmCampaignGuard", () => {
+  it("passes in interactive mode (no task mode)", () => {
+    expect(dmCampaignGuard("bereach_send_message", null)).toBeNull();
+  });
+
+  it("passes for non-DM tools in task mode", () => {
+    expect(dmCampaignGuard("bereach_visit_profile", taskMode())).toBeNull();
+  });
+
+  it("passes for DM tools with a campaign in task mode", () => {
+    expect(dmCampaignGuard("bereach_send_message", taskMode())).toBeNull();
+    expect(dmCampaignGuard("bereach_scheduled_message_create", taskMode())).toBeNull();
+    expect(dmCampaignGuard("bereach_draft_schedule", taskMode())).toBeNull();
+  });
+
+  it("blocks DMs in task mode without campaign", () => {
+    const tm = taskMode({ campaignId: undefined as unknown as string });
+    expect(dmCampaignGuard("bereach_send_message", tm)).toContain("BLOCKED");
+  });
+
+  it("blocks scheduled messages in task mode without campaign", () => {
+    const tm = taskMode({ campaignId: "" });
+    expect(dmCampaignGuard("bereach_scheduled_message_create", tm)).toContain("BLOCKED");
+  });
+});
+
+// ─── contextScopeGuard ─────────────────────────────────────────────
+
+describe("contextScopeGuard", () => {
+  it("passes for non-context tools", () => {
+    expect(contextScopeGuard("bereach_visit_profile", {}, taskMode())).toBeNull();
+  });
+
+  it("passes in interactive mode", () => {
+    expect(
+      contextScopeGuard("bereach_context_set", { type: "icp", scope: "user" }, null),
+    ).toBeNull();
+  });
+
+  it("passes when scope matches campaign in task mode", () => {
+    expect(
+      contextScopeGuard(
+        "bereach_context_set",
+        { type: "icp", scope: "campaign:camp-1" },
+        taskMode(),
+      ),
+    ).toBeNull();
+  });
+
+  it("blocks campaign-specific context saved as global in task mode", () => {
+    const result = contextScopeGuard(
+      "bereach_context_set",
+      { type: "icp", scope: "user" },
+      taskMode(),
+    );
+    expect(result).toContain("BLOCKED");
+    expect(result).toContain("campaign:camp-1");
+  });
+
+  it.each(["icp", "playbook", "tone-voice", "product-pitch"])(
+    "blocks '%s' context type saved as global scope in task mode",
+    (type) => {
+      expect(
+        contextScopeGuard("bereach_context_set", { type, scope: "user" }, taskMode()),
+      ).toContain("BLOCKED");
+    },
+  );
+
+  it("passes for non-campaign context types (e.g. dm_pacing_minutes) even in task mode", () => {
+    expect(
+      contextScopeGuard(
+        "bereach_context_set",
+        { type: "dm_pacing_minutes", scope: "user" },
+        taskMode(),
+      ),
+    ).toBeNull();
+  });
+
+  it("passes when no scope is provided but no campaign in task mode", () => {
+    expect(
+      contextScopeGuard(
+        "bereach_context_set",
+        { type: "icp" },
+        taskMode({ campaignId: "" }),
+      ),
+    ).toBeNull();
+  });
+});
+
+// ─── warmupActionGuard ─────────────────────────────────────────────
+
+describe("warmupActionGuard", () => {
+  it("passes in interactive mode", () => {
+    expect(warmupActionGuard("bereach_send_message", null)).toBeNull();
+  });
+
+  it("passes for non-warmup tasks", () => {
+    expect(warmupActionGuard("bereach_send_message", taskMode())).toBeNull();
+  });
+
+  it("passes for allowed warmup actions (like, comment, visit)", () => {
+    const tm = taskMode({ taskType: "warmup-engage" });
+    expect(warmupActionGuard("bereach_like_post", tm)).toBeNull();
+    expect(warmupActionGuard("bereach_visit_profile", tm)).toBeNull();
+    expect(warmupActionGuard("bereach_comment_on_post", tm)).toBeNull();
+    expect(warmupActionGuard("bereach_accept_invitation", tm)).toBeNull();
+  });
+
+  it("blocks DMs during warmup", () => {
+    const tm = taskMode({ taskType: "warmup-engage" });
+    expect(warmupActionGuard("bereach_send_message", tm)).toContain("BLOCKED");
+    expect(warmupActionGuard("bereach_scheduled_message_create", tm)).toContain("BLOCKED");
+    expect(warmupActionGuard("bereach_draft_schedule", tm)).toContain("BLOCKED");
+  });
+
+  it("blocks connection requests during warmup", () => {
+    const tm = taskMode({ taskType: "warmup-network" });
+    expect(warmupActionGuard("bereach_connect_profile", tm)).toContain("BLOCKED");
+  });
+});
+
+// ─── creditCapGuard ────────────────────────────────────────────────
+
+describe("creditCapGuard", () => {
+  it("passes in interactive mode", () => {
+    expect(creditCapGuard("bereach_visit_profile", 100, null, false)).toBeNull();
+  });
+
+  it("passes for free tools even in task mode", () => {
+    expect(creditCapGuard("bereach_contacts_search", 100, taskMode({ maxCredits: 10 }), true)).toBeNull();
+  });
+
+  it("passes when under budget", () => {
+    expect(creditCapGuard("bereach_visit_profile", 5, taskMode({ maxCredits: 30 }), false)).toBeNull();
+  });
+
+  it("passes when exactly at budget", () => {
+    expect(creditCapGuard("bereach_visit_profile", 30, taskMode({ maxCredits: 30 }), false)).toBeNull();
+  });
+
+  it("blocks when over budget", () => {
+    const result = creditCapGuard("bereach_visit_profile", 31, taskMode({ maxCredits: 30 }), false);
+    expect(result).toContain("BLOCKED");
+    expect(result).toContain("Credit budget exhausted");
+  });
+
+  it("includes correct count in message (credits - 1 for display)", () => {
+    const result = creditCapGuard("bereach_visit_profile", 31, taskMode({ maxCredits: 30 }), false);
+    expect(result).toContain("30/30");
+  });
+});