bereach-openclaw 1.6.13 → 1.6.14

package/node_modules/@bereach/tools/src/enforcement-types.ts

@@ -38,6 +38,14 @@ export const READ_TOOLS = new Set([
   "bereach_get_connections",
   "bereach_resolve_parameters",
   "bereach_inbox_unread_count",
+  // Chat agent tools (same LinkedIn actions, different naming convention)
+  "bereach_search_people",
+  "bereach_search_posts",
+  "bereach_search_companies",
+  "bereach_search_jobs",
+  "bereach_search_by_url",
+  "bereach_search_sales_nav_people",
+  "bereach_search_sales_nav_companies",
 ]);
 
 /** LinkedIn write operations (DM, connect, like, comment, etc.). Higher pacing. 1 credit each. */

package/openclaw.plugin.json

@@ -1,7 +1,7 @@
 {
   "id": "bereach-openclaw",
   "name": "BeReach",
-  "version": "1.6.13",
+  "version": "1.6.14",
   "description": "LinkedIn outreach automation — 75+ tools, hook-based enforcement, dynamic context",
   "configSchema": {
     "type": "object",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bereach-openclaw",
-  "version": "1.6.13",
+  "version": "1.6.14",
   "description": "BeReach LinkedIn automation plugin for OpenClaw",
   "license": "AGPL-3.0",
   "exports": {

package/src/hooks/context/index.ts

@@ -6,7 +6,7 @@
  * Uses TTL cache so only the first turn hits the API.
  */
 
-import { getOrFetch, sessionStart, invalidateAndRefresh, type CacheStore, type ContextEntry } from "../cache";
+import { getOrFetch, sessionStart, type CacheStore, type ContextEntry } from "../cache";
 import { SOUL_TEMPLATE } from "../../soul-template-content";
 
 import { type SessionState, detectTaskMode } from "../types";
@@ -70,7 +70,17 @@ export function resetProfileState(state: SessionState) {
 // Soul template fetcher
 // ---------------------------------------------------------------------------
 
+// Module-level soul cache — the soul template changes only when the user
+// updates ICP/tone/playbook, which is rare. Refetching every turn wastes
+// ~1-3s of API latency. 5-minute TTL matches Anthropic prompt cache TTL.
+let _soulCache: { text: string; fetchedAt: number; key: string } | null = null;
+const SOUL_TTL_MS = 5 * 60 * 1000;
+
 async function fetchSoulTemplate(apiKey?: string): Promise<string> {
+  const key = apiKey ?? "";
+  if (_soulCache && _soulCache.key === key && Date.now() - _soulCache.fetchedAt < SOUL_TTL_MS) {
+    return _soulCache.text;
+  }
   try {
     const headers: Record<string, string> = {};
     if (apiKey) headers.Authorization = `Bearer ${apiKey}`;
@@ -78,14 +88,25 @@ async function fetchSoulTemplate(apiKey?: string): Promise<string> {
       headers,
       signal: AbortSignal.timeout(3000),
     });
-    if (!res.ok) return SOUL_TEMPLATE;
+    if (!res.ok) {
+      _soulCache = { text: SOUL_TEMPLATE, fetchedAt: Date.now(), key };
+      return SOUL_TEMPLATE;
+    }
     const { soul } = await res.json();
-    return typeof soul === "string" && soul.includes(MARKER_START) ? soul : SOUL_TEMPLATE;
+    const result = typeof soul === "string" && soul.includes(MARKER_START) ? soul : SOUL_TEMPLATE;
+    _soulCache = { text: result, fetchedAt: Date.now(), key };
+    return result;
   } catch {
+    _soulCache = { text: SOUL_TEMPLATE, fetchedAt: Date.now(), key };
     return SOUL_TEMPLATE;
   }
 }
 
+/** Clear the soul template cache. Called by tracking hook when contexts change. */
+export function clearSoulCache(): void {
+  _soulCache = null;
+}
+
 // ---------------------------------------------------------------------------
 // Profile auto-init + daily refresh
 // ---------------------------------------------------------------------------
@@ -206,12 +227,38 @@ function buildInteractiveContext(
 // Hook registration
 // ---------------------------------------------------------------------------
 
+// Module-level dedup: OpenClaw calls register() with two api instances, both
+// fire before_prompt_build for the same turn. Without dedup, we make double
+// HTTP calls (soul + snapshot) and double-build the context. The inflight
+// promise lets the second hook reuse the first's result.
+let _inflightBuild: { promise: Promise<any>; at: number } | null = null;
+
 export function registerContextHook(api: any, apiKey: string | undefined, state: SessionState) {
   if (typeof api?.on !== "function") return;
 
   api.on(
     "before_prompt_build",
     async (promptCtx: any) => {
+      try {
+        // Dedup: if another hook instance is already building context for this
+        // turn (within 200ms), reuse its result instead of duplicating work.
+        if (_inflightBuild && Date.now() - _inflightBuild.at < 200) {
+          log("context: SKIP duplicate hook (reusing inflight)");
+          return _inflightBuild.promise;
+        }
+        const buildPromise = _buildContext(promptCtx, api, apiKey, state);
+        _inflightBuild = { promise: buildPromise, at: Date.now() };
+        return buildPromise;
+      } catch (err) {
+        log(`error: ${errMsg(err)}`);
+        return { appendSystemContext: SOUL_TEMPLATE };
+      }
+    },
+    { priority: 5 },
+  );
+}
+
+async function _buildContext(promptCtx: any, api: any, apiKey: string | undefined, state: SessionState): Promise<any> {
       try {
         // Track active sessions so clearAll() at agent_end doesn't wipe cache for concurrent sessions.
         // Only call once per session — before_prompt_build fires every turn, but sessionEnd is once.
@@ -303,13 +350,11 @@ export function registerContextHook(api: any, apiKey: string | undefined, state:
         }
 
         // INTERACTIVE MODE
-        // Force-refresh the live snapshot on every turn so the agent never
-        // reports stale status ("10 active campaigns" while the UI shows all
-        // paused). One extra /agent/snapshot call per turn is fine — chat turns
-        // are infrequent and the cost of staleness is a hallucinated reply.
-        // Task mode keeps the cache because tasks run in isolation and don't
-        // need mid-run refresh.
-        invalidateAndRefresh("credits");
+        // Cache serves soul + snapshot from memory when fresh (TTL-based).
+        // Tool-call tracking already invalidates specific keys on mutation
+        // (credits, contexts, pipeline, drafts). No need to force-refresh
+        // the entire snapshot every turn — it adds 2-3 blocking HTTP calls
+        // (~3-4s latency) per message.
         const [soulTemplate, liveData] = await Promise.all([
           fetchSoulTemplate(key),
           getOrFetch(key),
@@ -380,9 +425,6 @@ export function registerContextHook(api: any, apiKey: string | undefined, state:
         log(`error: ${errMsg(err)}`);
         return { appendSystemContext: SOUL_TEMPLATE };
       }
-    },
-    { priority: 5 },
-  );
 }
 
 // ---------------------------------------------------------------------------

package/src/hooks/lifecycle.ts

@@ -106,7 +106,15 @@ export function registerLifecycleHook(
       state.onboardingDirectiveInjected = false;
       state.sessionStarted = false;
     }
-    clearAllSafe();
+
+    // Interactive mode: preserve cache across turns. The same user continues the
+    // conversation, so wiping forces 2-3 redundant HTTP calls per turn (~3-4s
+    // latency). TTL handles staleness; tool-call tracking invalidates specific
+    // keys on mutation. Multi-user key mismatch handled by getOrFetch().
+    // Task mode: clear cache so the next task gets fresh data for its campaign.
+    if (isTaskMode) {
+      clearAllSafe();
+    }
 
     // Reset per-turn state (always safe to reset)
     state.toolCallCount = 0;

package/src/hooks/tracking.ts

@@ -5,7 +5,7 @@
  */
 
 import { invalidate, invalidateAndRefresh, clearAllSafe } from "./cache";
-import { resetProfileState } from "./context";
+import { resetProfileState, clearSoulCache } from "./context";
 import { FREE_TOOLS, PACED_FREE_TOOLS, type SessionState } from "./types";
 import {
   errMsg,
@@ -245,7 +245,7 @@ export function registerTrackingHook(api: any, state: SessionState) {
 
       if (CONTACT_MUTATION_TOOLS.has(toolName)) invalidateAndRefresh("pipeline");
       if (DRAFT_MUTATION_TOOLS.has(toolName)) invalidateAndRefresh("pendingDrafts");
-      if (toolName === "bereach_context_set" || toolName === "bereach_context_delete") invalidateAndRefresh("contexts");
+      if (toolName === "bereach_context_set" || toolName === "bereach_context_delete") { invalidateAndRefresh("contexts"); clearSoulCache(); }
       if (toolName === "bereach_switch_account") { clearAllSafe(); resetProfileState(state); log("account switch: cleared caches + reset profile state"); }
       if (CAMPAIGN_MUTATION_TOOLS.has(toolName)) clearAllSafe();
     } catch (err) {