bereach-openclaw 1.5.10 → 1.5.11

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

@@ -3,12 +3,12 @@
  * Single source of truth, used by both lifecycle hook and connector.
  */
 
-/** Model pricing per 1M tokens */
-export const MODEL_PRICING: Record<string, { input: number; output: number; cacheRead: number }> = {
-  "haiku": { input: 1.0, output: 5.0, cacheRead: 0.1 },
-  "sonnet": { input: 3.0, output: 15.0, cacheRead: 0.3 },
-  "flash": { input: 0.3, output: 2.5, cacheRead: 0.03 },
-  "pro": { input: 1.25, output: 10.0, cacheRead: 0.125 },
+/** Model pricing per 1M tokens (Anthropic 5-min cache, Google standard) */
+export const MODEL_PRICING: Record<string, { input: number; output: number; cacheRead: number; cacheWrite: number }> = {
+  "haiku": { input: 1.0, output: 5.0, cacheRead: 0.1, cacheWrite: 1.25 },
+  "sonnet": { input: 3.0, output: 15.0, cacheRead: 0.3, cacheWrite: 3.75 },
+  "flash": { input: 0.3, output: 2.5, cacheRead: 0.03, cacheWrite: 0.375 },
+  "pro": { input: 1.25, output: 10.0, cacheRead: 0.125, cacheWrite: 1.5625 },
 };
 
 export type TokenUsage = {
@@ -21,25 +21,29 @@ export type TokenUsage = {
 /**
  * Estimate cost in USD from token usage.
  * Matches model by substring (e.g. "claude-3-5-haiku" matches "haiku").
+ * Includes cache write costs (Anthropic 5-min ephemeral cache).
  */
 export function estimateTaskCost(
   inputTokens: number,
   outputTokens: number,
   cacheReadTokens: number,
   modelSlug?: string | null,
+  cacheWriteTokens?: number,
 ): number {
   const key = Object.keys(MODEL_PRICING).find((k) => modelSlug?.includes(k)) ?? "haiku";
   const p = MODEL_PRICING[key];
   const uncached = Math.max(0, inputTokens - cacheReadTokens);
-  return (uncached * p.input + cacheReadTokens * p.cacheRead + outputTokens * p.output) / 1_000_000;
+  const writeCost = (cacheWriteTokens ?? 0) * p.cacheWrite;
+  return (uncached * p.input + cacheReadTokens * p.cacheRead + outputTokens * p.output + writeCost) / 1_000_000;
 }
 
 /**
  * Extract token usage from an OpenClaw meta/wrapper object.
- * Handles multiple data locations across OpenClaw versions:
+ * Handles multiple data locations and field naming conventions across OpenClaw versions:
  *   - meta.agentMeta.lastCallUsage (OpenClaw 2026.4+)
- *   - meta.cost (older versions / test runner)
+ *   - meta.cost (CLI --json output / older versions)
  *   - meta.usage (alternative format)
+ *   - Both camelCase and snake_case field names
  */
 export function extractTokenUsage(
   meta: Record<string, unknown>,
@@ -49,13 +53,26 @@ export function extractTokenUsage(
   const costData = (meta.cost ?? {}) as Record<string, number>;
   const usageData = (meta.usage ?? {}) as Record<string, number>;
 
-  const inputTokens = lastCall.input ?? costData.inputTokens ?? costData.input ?? usageData.input ?? 0;
-  const outputTokens = lastCall.output ?? costData.outputTokens ?? costData.output ?? usageData.output ?? 0;
+  // Resolve input/output tokens across all naming conventions (camelCase + snake_case)
+  const inputTokens =
+    lastCall.input ?? lastCall.input_tokens ??
+    costData.inputTokens ?? costData.input_tokens ?? costData.input ??
+    usageData.input ?? usageData.inputTokens ?? usageData.input_tokens ?? 0;
+  const outputTokens =
+    lastCall.output ?? lastCall.output_tokens ??
+    costData.outputTokens ?? costData.output_tokens ?? costData.output ??
+    usageData.output ?? usageData.outputTokens ?? usageData.output_tokens ?? 0;
 
   if (inputTokens === 0 && outputTokens === 0) return null;
 
-  const cacheRead = lastCall.cacheRead ?? usageData.cacheRead ?? costData.cacheReadTokens ?? 0;
-  const cacheWrite = lastCall.cacheWrite ?? usageData.cacheWrite ?? costData.cacheWriteTokens ?? 0;
+  const cacheRead =
+    lastCall.cacheRead ?? lastCall.cache_read_input_tokens ??
+    usageData.cacheRead ?? usageData.cache_read_input_tokens ??
+    costData.cacheReadTokens ?? costData.cache_read_input_tokens ?? 0;
+  const cacheWrite =
+    lastCall.cacheWrite ?? lastCall.cache_write_input_tokens ??
+    usageData.cacheWrite ?? usageData.cache_write_input_tokens ??
+    costData.cacheWriteTokens ?? costData.cache_write_input_tokens ?? 0;
 
   return {
     usage: {
@@ -64,6 +81,6 @@ export function extractTokenUsage(
       ...(cacheRead > 0 ? { cacheReadTokens: cacheRead } : {}),
       ...(cacheWrite > 0 ? { cacheWriteTokens: cacheWrite } : {}),
     },
-    model: agentMeta.model as string | undefined,
+    model: (agentMeta.model ?? meta.model) as string | undefined,
   };
 }

package/openclaw.plugin.json

@@ -1,7 +1,7 @@
 {
   "id": "bereach-openclaw",
   "name": "BeReach",
-  "version": "1.5.10",
+  "version": "1.5.11",
   "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.5.10",
+  "version": "1.5.11",
   "description": "BeReach LinkedIn automation plugin for OpenClaw",
   "license": "AGPL-3.0",
   "exports": {

package/src/commands/connector/execution.ts

@@ -19,8 +19,21 @@ export function enrichResultWithTokens(
 ): void {
   if (result.tokenUsage) return; // already enriched (e.g. by lifecycle hook)
   const resultObj = output?.result as Record<string, unknown> | undefined;
+
+  // Try multiple locations where OpenClaw might place cost/usage data
   const meta = (resultObj?.meta ?? output?.meta ?? {}) as Record<string, unknown>;
-  const extracted = extractTokenUsage(meta);
+  let extracted = extractTokenUsage(meta);
+
+  // Fallback: output.cost directly (some OpenClaw versions put cost at top level)
+  if (!extracted && output?.cost) {
+    extracted = extractTokenUsage({ cost: output.cost } as Record<string, unknown>);
+  }
+
+  // Fallback: output.usage directly
+  if (!extracted && output?.usage) {
+    extracted = extractTokenUsage({ usage: output.usage } as Record<string, unknown>);
+  }
+
   if (!extracted?.usage) return;
   const effectiveModel = extracted.model ?? modelSlug ?? undefined;
   result.tokenUsage = extracted.usage;
@@ -30,9 +43,10 @@ export function enrichResultWithTokens(
     extracted.usage.outputTokens,
     extracted.usage.cacheReadTokens ?? 0,
     effectiveModel,
+    extracted.usage.cacheWriteTokens ?? 0,
   );
   const u = extracted.usage;
-  console.log(`[connector] Tokens: in=${u.inputTokens} out=${u.outputTokens} cache=${u.cacheReadTokens ?? 0} cost=$${result.estimatedCostUsd.toFixed(4)} model=${effectiveModel ?? "unknown"}`);
+  console.log(`[connector] Tokens: in=${u.inputTokens} out=${u.outputTokens} cacheR=${u.cacheReadTokens ?? 0} cacheW=${u.cacheWriteTokens ?? 0} cost=$${result.estimatedCostUsd.toFixed(4)} model=${effectiveModel ?? "unknown"}`);
 }
 
 // ---------------------------------------------------------------------------
@@ -47,8 +61,10 @@ export async function executeViaWebhook(
   const maxCredits = (task.payload as Record<string, unknown>)?.maxCredits ?? 100;
   const timeoutMs = (task.timeoutSeconds || 300) * 1000;
 
-  // Encode task metadata in the session name (Strategy 1 for detectTaskMode)
-  const sessionName = task.sessionKey || `hook:${task.id}:${task.campaignId ?? ""}:${task.type}`;
+  // Session reuse: use a stable session name per campaign+type so the Anthropic
+  // prompt cache carries over between consecutive tasks (~80% savings per task).
+  // The unique taskId is passed via TASK_META in the message body instead.
+  const sessionName = task.sessionKey || `hook:task:${task.campaignId ?? ""}:${task.type}`;
 
   // Also encode in message as fallback (Strategy 4: TASK_META bracket format)
   const taskMessage = `[TASK_META: taskType=${task.type} taskId=${task.id} campaignId=${task.campaignId ?? ""} maxCredits=${maxCredits}]\n\n${message}`;

package/src/hooks/context/index.ts

@@ -142,39 +142,56 @@ async function autoInitProfile(state: SessionState, data: CacheStore, apiKey: st
 // Interactive context builder
 // ---------------------------------------------------------------------------
 
+/**
+ * Build interactive context, split into static (cacheable) and dynamic (per-turn) parts.
+ *
+ * The OpenClaw gateway treats `appendSystemContext` as provider-cacheable and
+ * `prependContext` as per-turn. By separating the soul template (static, ~8KB)
+ * from the live status (dynamic), the gateway can cache the soul template across
+ * all turns in a session via Anthropic prompt caching — saving ~90% on those tokens.
+ */
 function buildInteractiveContext(
   state: SessionState,
   soulTemplate: string,
   liveData: CacheStore,
   apiKey: string,
-): string {
+): { staticContext: string; dynamicContext: string } {
   const liveStatus = formatLiveStatus(state, liveData, apiKey);
   const activityBlock = formatRecentActivity(liveData.recentEvents);
   const toneDirective = formatToneInferenceDirective(state, liveData);
-  let fullContext = soulTemplate + "\n" + liveStatus + activityBlock;
 
-  if (toneDirective) fullContext += toneDirective;
+  // Static part: soul template with rules, identity, protocols — identical every turn.
+  // Goes into appendSystemContext so the gateway can cache it.
+  const staticContext = soulTemplate;
+
+  // Dynamic part: live status, activity, tone, warnings — changes per turn.
+  // Goes into prependContext so it doesn't invalidate the cached soul template.
+  let dynamicContext = liveStatus + activityBlock;
+
+  if (toneDirective) dynamicContext += toneDirective;
 
   if (!state.anthropicKeyWarningInjected) {
     const anthropicWarning = formatAnthropicKeyWarning();
-    if (anthropicWarning) fullContext += anthropicWarning;
+    if (anthropicWarning) dynamicContext += anthropicWarning;
     state.anthropicKeyWarningInjected = true;
   }
 
+  const totalLength = staticContext.length + dynamicContext.length;
+
   // Size guard — log warning but NEVER truncate. User content (ICP, playbook, tone)
   // must always be injected in full. Truncating can silently drop critical instructions
   // that the agent needs for correct outreach and qualification. The LLM context window
   // is large enough to handle the full context in practice.
-  if (fullContext.length > MAX_CONTEXT_CHARS) {
-    log(`context size WARNING: ${fullContext.length} chars exceeds ${MAX_CONTEXT_CHARS} soft limit (NOT truncating)`);
+  if (totalLength > MAX_CONTEXT_CHARS) {
+    log(`context size WARNING: ${totalLength} chars exceeds ${MAX_CONTEXT_CHARS} soft limit (NOT truncating)`);
   }
 
   const yn = (v: unknown) => (v ? "yes" : "no");
   const ob = liveData.onboardingState;
-  log(`context: soul=${soulTemplate.length} live=${liveStatus.length} tone=${yn(toneDirective)} total=${fullContext.length}`);
+  log(`context: soul=${staticContext.length} live=${liveStatus.length} tone=${yn(toneDirective)} total=${totalLength} (static=${staticContext.length} dynamic=${dynamicContext.length})`);
   log(`sections: account=${yn(liveData.activeAccount)} credits=${yn(liveData.credits)} limits=${yn(liveData.limits)} pipeline=${yn(liveData.pipeline)} contexts=${liveData.contexts.length} campaigns=${liveData.activeCampaigns.length} drafts=${liveData.pendingDrafts} failed=${liveData.failedDrafts} unread=${liveData.unreadDMs} onboarding=${ob == null ? "null" : ob.completed ? "done" : "pending"} firstSession=${yn(!liveData.sessionMeta?.lastSessionAt)}`);
 
-  return fullContext;
+  return { staticContext, dynamicContext };
 }
 
 // ---------------------------------------------------------------------------
@@ -287,9 +304,14 @@ export function registerContextHook(api: any, apiKey: string | undefined, state:
 
         await autoInitProfile(state, liveData, key);
 
-        const fullContext = buildInteractiveContext(state, soulTemplate, liveData, key);
+        const { staticContext, dynamicContext } = buildInteractiveContext(state, soulTemplate, liveData, key);
 
-        return { appendSystemContext: fullContext };
+        // appendSystemContext = cached by gateway (soul template, static across turns)
+        // prependContext = per-turn dynamic data (live status, activity, tone)
+        return {
+          appendSystemContext: staticContext,
+          prependContext: dynamicContext,
+        };
       } catch (err) {
         log(`error: ${errMsg(err)}`);
         return { appendSystemContext: SOUL_TEMPLATE };

package/src/hooks/detect-task-mode.ts

@@ -26,15 +26,17 @@ export function detectTaskMode(sessionKey: string | undefined | null, metadata?:
   // Without a valid ID, the lifecycle hook can't POST results to /api/tasks/:id/result.
   const fallbackTaskId = () => `local-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
 
-  // Strategy 1: sessionKey format "hook:{userId}:{campaignId}:{type}"
+  // Strategy 1: sessionKey format "hook:{taskId|task}:{campaignId}:{type}"
   // The connector/workflow sets the session key during task creation.
-  // parts[1] = userId, parts[2] = campaignId, parts[3+] = taskType
-  // The actual taskId comes from metadata (set by TASK_META in the message).
+  // New format uses "task" as a stable placeholder for session reuse (prompt caching).
+  // The actual taskId always comes from metadata (set by TASK_META in the message).
   if (sessionKey?.startsWith("hook:")) {
     const parts = sessionKey.split(":");
     if (parts.length >= 4) {
+      // parts[1] is "task" (reusable session) or a legacy taskId
+      const sessionPart = parts[1];
       return {
-        taskId: (metadata?.taskId as string) || parts[1] || fallbackTaskId(),
+        taskId: (metadata?.taskId as string) || (sessionPart !== "task" ? sessionPart : null) || fallbackTaskId(),
         taskType: parts.slice(3).join(":"),
         campaignId: parts[2] || null,
         maxCredits: parseMaxCredits(metadata?.maxCredits),

package/src/hooks/lifecycle.ts

@@ -70,16 +70,52 @@ function enrichWithTokenUsage(
   taskMode: TaskModeInfo,
 ): void {
   try {
-    // Strategy 1: Try endCtx.meta (works on OpenClaw 2026.4+ if/when they expose agentMeta)
-    const meta = (endCtx as any)?.meta ?? (endCtx as any)?.result?.meta ?? {};
-    let extracted = extractTokenUsage(meta);
+    const ctx = endCtx as Record<string, unknown> | undefined;
+    let extracted: ReturnType<typeof extractTokenUsage> = null;
+
+    // Strategy 1a: Try endCtx.meta (OpenClaw 2026.4+ when agentMeta is exposed)
+    const topMeta = (ctx?.meta ?? {}) as Record<string, unknown>;
+    if (Object.keys(topMeta).length > 0) {
+      extracted = extractTokenUsage(topMeta);
+    }
+
+    // Strategy 1b: Try endCtx.result.meta (CLI --json wrapper structure)
+    // The ?? chain was broken: if endCtx.meta was {} (truthy), result.meta was never checked
+    if (!extracted) {
+      const resultMeta = ((ctx?.result as Record<string, unknown>)?.meta ?? {}) as Record<string, unknown>;
+      if (Object.keys(resultMeta).length > 0) {
+        extracted = extractTokenUsage(resultMeta);
+      }
+    }
+
+    // Strategy 1c: Try endCtx.cost directly (some versions put cost at top level)
+    if (!extracted && ctx?.cost) {
+      extracted = extractTokenUsage({ cost: ctx.cost } as Record<string, unknown>);
+    }
 
     // Strategy 2: Extract from assistant messages' .usage fields
     // OpenClaw v2026.2.x stores per-turn token usage on each assistant message
     // but does not include agentMeta in the agent_end hook context.
+    // With session reuse (prompt caching), messages include history from previous
+    // tasks. Scope to only the CURRENT task by finding the last TASK_META message
+    // matching this taskId, and counting only messages after it.
+    const allMessages: Array<{ role?: string; content?: unknown; usage?: Record<string, unknown>; model?: string }> = (ctx?.messages ?? []) as any;
     if (!extracted) {
-      const allMessages: Array<{ role?: string; usage?: Record<string, unknown>; model?: string }> = (endCtx as any)?.messages ?? [];
-      const fromMessages = extractUsageFromMessages(allMessages);
+      let taskStartIdx = 0;
+      if (taskMode.taskId) {
+        for (let i = allMessages.length - 1; i >= 0; i--) {
+          const msg = allMessages[i];
+          if (msg.role === "user") {
+            const text = extractTextFromContent(msg.content);
+            if (text.includes(`taskId=${taskMode.taskId}`)) {
+              taskStartIdx = i;
+              break;
+            }
+          }
+        }
+      }
+      const taskMessages = allMessages.slice(taskStartIdx);
+      const fromMessages = extractUsageFromMessages(taskMessages as any);
       if (fromMessages) {
         extracted = {
           usage: {
@@ -90,12 +126,17 @@ function enrichWithTokenUsage(
           },
           model: fromMessages.model,
         };
-        log(`token usage: extracted from ${allMessages.filter(m => m.role === "assistant").length} assistant messages for ${taskMode.taskId}`);
+        log(`token usage: extracted from ${taskMessages.filter(m => m.role === "assistant").length} assistant messages (of ${allMessages.length} total) for ${taskMode.taskId}`);
       }
     }
 
     if (!extracted) {
-      log(`token usage: no data in endCtx.meta or messages for ${taskMode.taskId} (meta keys: ${Object.keys(meta).join(",")})`);
+      // Diagnostic: log the actual shape so we can trace what OpenClaw provides
+      const ctxKeys = Object.keys(ctx ?? {}).join(",");
+      const metaKeys = Object.keys(topMeta).join(",");
+      const assistantMsgs = allMessages.filter(m => m.role === "assistant");
+      const sampleKeys = assistantMsgs.length > 0 ? Object.keys(assistantMsgs[0]).join(",") : "none";
+      log(`token usage: NO DATA for ${taskMode.taskId} | endCtx=[${ctxKeys}] meta=[${metaKeys}] msgs=${allMessages.length} assistants=${assistantMsgs.length} sampleMsgKeys=[${sampleKeys}]`);
       return;
     }
 
@@ -108,10 +149,11 @@ function enrichWithTokenUsage(
       extracted.usage.outputTokens,
       extracted.usage.cacheReadTokens ?? 0,
       modelSlug,
+      extracted.usage.cacheWriteTokens ?? 0,
     );
 
     const u = extracted.usage;
-    log(`tokens ${taskMode.taskId}: in=${u.inputTokens} out=${u.outputTokens} cache=${u.cacheReadTokens ?? 0} cost=$${(taskResult.estimatedCostUsd as number).toFixed(4)} model=${modelSlug ?? "unknown"}`);
+    log(`tokens ${taskMode.taskId}: in=${u.inputTokens} out=${u.outputTokens} cacheR=${u.cacheReadTokens ?? 0} cacheW=${u.cacheWriteTokens ?? 0} cost=$${(taskResult.estimatedCostUsd as number).toFixed(4)} model=${modelSlug ?? "unknown"}`);
   } catch (err) {
     log(`token usage extraction failed: ${errMsg(err)}`);
   }
@@ -141,10 +183,12 @@ export function registerLifecycleHook(
     let taskMode: TaskModeInfo | null = null;
 
     // Strategy 1: recover from TASK_META in endCtx.messages (always works, immune to race)
+    // With session reuse (prompt caching), multiple tasks run in the same session.
+    // Use the LAST matching user message to get the most recent task's metadata.
     const allMessages: Array<{ role?: string; content?: unknown }> = endCtx?.messages ?? [];
     const userMsgs = allMessages.filter((m: any) => m.role === "user");
-    for (const userMsg of userMsgs) {
-      const msgText = extractTextFromContent(userMsg?.content);
+    for (let i = userMsgs.length - 1; i >= 0; i--) {
+      const msgText = extractTextFromContent(userMsgs[i]?.content);
       const match = msgText.match(TASK_META_RE);
       if (match?.[1] && match?.[2]) {
         taskMode = {