bereach-openclaw 1.5.9 → 1.5.10

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

@@ -170,7 +170,7 @@ export const PACING = {
 export const DEFAULTS = {
   maxVisitsPerSession: 200,
   engagementThreshold: 5,
-  contextCacheTtlMs: 5 * 60 * 1000, // 5 minutes
+  contextCacheTtlMs: 15 * 60 * 1000, // 15 minutes
   maxResultItems: 15,
   maxPostTextLength: 500,
 } as const;

package/openclaw.plugin.json

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

package/src/commands/connector/execution.ts

@@ -42,7 +42,7 @@ export function enrichResultWithTokens(
 export async function executeViaWebhook(
   config: ConnectorConfig,
   task: NonNullable<PullResponse["task"]>,
-): Promise<{ result: TaskResult | null; error: string | null }> {
+): Promise<{ result: TaskResult | null; error: string | null; deferred?: boolean }> {
   const message = task.message || `Execute ${task.type} task`;
   const maxCredits = (task.payload as Record<string, unknown>)?.maxCredits ?? 100;
   const timeoutMs = (task.timeoutSeconds || 300) * 1000;
@@ -99,6 +99,17 @@ export async function executeViaWebhook(
       return { result: null, error: String(output.error).slice(0, 500) };
     }
 
+    // HTTP 202 Accepted = fire-and-forget. The gateway accepted the task but the
+    // agent hasn't run yet. The lifecycle hook (agent_end) inside the gateway will
+    // POST the real result (with token usage, contacts processed, etc.) when done.
+    // Do NOT submit a premature empty result here - it would win the race against
+    // the lifecycle hook and store { success: true } with no data.
+    if (res.status === 202) {
+      const runId = output.runId ?? "unknown";
+      console.log(`[connector] Webhook accepted (202) task ${task.id}, runId=${runId} - deferring result to lifecycle hook`);
+      return { result: null, error: null, deferred: true };
+    }
+
     const webhookResult = (output.result as TaskResult) ?? { success: true };
     enrichResultWithTokens(webhookResult, output, task.model);
     return { result: webhookResult, error: null };
@@ -112,11 +123,13 @@ export async function executeViaWebhook(
 /**
  * Execute a task via webhook.
  * Returns webhookDead=true if the hooks endpoint returned 404 (gateway restart needed).
+ * Returns deferred=true if the gateway accepted the task (202) and the lifecycle hook
+ * will submit the result — the connector should NOT submit a result in this case.
  */
 export async function executeOnOpenClaw(
   config: ConnectorConfig,
   task: NonNullable<PullResponse["task"]>,
-): Promise<{ result: TaskResult | null; error: string | null; webhookDead?: boolean }> {
+): Promise<{ result: TaskResult | null; error: string | null; webhookDead?: boolean; deferred?: boolean }> {
   const res = await executeViaWebhook(config, task);
   if (res.error?.startsWith("Webhook HTTP 404")) {
     console.warn(`[connector] Webhook returned 404 for task ${task.id} — hooks endpoint lost`);

package/src/commands/connector/index.ts

@@ -171,7 +171,7 @@ export async function runConnectorLoop(
 
           const execResult = await Promise.race([
             executeOnOpenClaw(config, task),
-            new Promise<{ result: null; error: string; webhookDead?: boolean }>((resolve) => {
+            new Promise<{ result: null; error: string; webhookDead?: boolean; deferred?: boolean }>((resolve) => {
               const check = setTimeout(() => {
                 if (watchdogFired) {
                   resolve({ result: null, error: `Watchdog: task execution exceeded ${Math.round(watchdogMs / 1000)}s timeout` });
@@ -198,33 +198,41 @@ export async function runConnectorLoop(
           }
           clearTimeout(watchdogTimer);
 
-          const taskStatus = error ? "failed" : (result?.success !== false ? "succeeded" : "failed");
-          const execDuration = Date.now() - (task as any)._startedAt;
-          console.log(`[connector] Task ${task.id} ${taskStatus} (${Math.round(execDuration / 1000)}s)${error ? `: ${error.slice(0, 100)}` : ""}${result?.reason ? ` reason=${result.reason}` : ""}`);
+          // When deferred=true, the gateway accepted the task (HTTP 202) and the
+          // lifecycle hook inside the gateway will submit the real result with full
+          // data (token usage, contacts processed, etc.). The connector must NOT
+          // submit a premature empty result that would win the race.
+          if (execResult.deferred) {
+            const execDuration = Date.now() - (task as any)._startedAt;
+            console.log(`[connector] Task ${task.id} dispatched to gateway (${Math.round(execDuration / 1000)}s) — result deferred to lifecycle hook`);
+          } else {
+            const taskStatus = error ? "failed" : (result?.success !== false ? "succeeded" : "failed");
+            const execDuration = Date.now() - (task as any)._startedAt;
+            console.log(`[connector] Task ${task.id} ${taskStatus} (${Math.round(execDuration / 1000)}s)${error ? `: ${error.slice(0, 100)}` : ""}${result?.reason ? ` reason=${result.reason}` : ""}`);
+
+            if (!error && result?.success === false && (result as any)?.toolCallCount === 0 && execDuration < 10_000) {
+              console.warn(`[connector] DIAGNOSTIC: Task ${task.id} failed in <10s with 0 tool calls`);
+            }
 
-          if (!error && result?.success === false && (result as any)?.toolCallCount === 0 && execDuration < 10_000) {
-            console.warn(`[connector] DIAGNOSTIC: Task ${task.id} failed in <10s with 0 tool calls`);
-          }
+            // Scan for LLM provider errors
+            const allText = [error, result?.error, (result as any)?.reason].filter(Boolean).join(" ");
+            const llmError = detectLlmError(allText);
+            if (llmError && result && result.success !== false) {
+              console.warn(`[connector] LLM provider error detected in task ${task.id}: ${llmError}`);
+              result.success = false;
+              if (!result.error) result.error = `LLM provider error: ${llmError}`;
+            }
 
-          // Scan for LLM provider errors
-          const allText = [error, result?.error, (result as any)?.reason].filter(Boolean).join(" ");
-          const llmError = detectLlmError(allText);
-          if (llmError && result && result.success !== false) {
-            console.warn(`[connector] LLM provider error detected in task ${task.id}: ${llmError}`);
-            result.success = false;
-            if (!result.error) result.error = `LLM provider error: ${llmError}`;
+            // Submit result only when NOT deferred. When the gateway returns a
+            // synchronous result (non-202), the connector acts as a safety net.
+            const derivedError = error ?? (
+              result?.success === false
+                ? (result.error ?? result.reason ?? "Task failed (no details from agent)")
+                : undefined
+            );
+            await submitResult(config, task.id, result, derivedError ?? null);
           }
 
-          // Safety-net submission — lifecycle hook usually reports first,
-          // but if it fails silently the result endpoint's optimistic lock
-          // ensures double-submissions are harmless.
-          const derivedError = error ?? (
-            result?.success === false
-              ? (result.error ?? result.reason ?? "Task failed (no details from agent)")
-              : undefined
-          );
-          await submitResult(config, task.id, result, derivedError ?? null);
-
           totalTasksExecuted++;
           pollInterval = 5_000;
         } finally {

package/src/hooks/context/formatters.ts

@@ -6,6 +6,7 @@
 import { cacheSet, type CacheStore, type ContextEntry, type OnboardingState, type RecentEvent } from "../cache";
 import { type DbCampaign, type SessionState } from "../types";
 import { errMsg, createLogger, CHAT_BASE, PRICING_URL, apiFetch } from "../utils";
+import { readEnv } from "../../env";
 
 const log = createLogger("context");
 
@@ -286,10 +287,13 @@ export function formatUpgradeSignals(data: CacheStore): string {
 // ---------------------------------------------------------------------------
 
 export function formatAnthropicKeyWarning(): string {
+  const key = readEnv("ANTHROPIC_API_KEY");
+  // No key or already subscription → nothing to warn about
+  if (!key || key.startsWith("sk-ant-oat")) return "";
   return (
-    "\n### Anthropic API Key Check\n\n" +
-    "Silently check the Anthropic API key prefix: `sk-ant-oat` = subscription (OK, say nothing). " +
-    "Other prefix = pay-per-use → warn user to switch to subscription key. Skip if key not found.\n"
+    "\n### Anthropic API Key Warning\n\n" +
+    "The Anthropic API key uses pay-per-use billing (not subscription). " +
+    "Recommend the user switch to a subscription key (`sk-ant-oat-*`) to reduce costs.\n"
   );
 }
 
@@ -563,7 +567,7 @@ export function formatLiveStatus(state: SessionState, data: CacheStore, apiKey?:
 
   // Anti-cron directive: campaigns are automated by the task scheduler, not crons
   if (hasCampaigns) {
-    lines.push("**Scheduling**: Campaign automation is handled by the task scheduler and connector. Do NOT suggest cron-based scheduling, polling setups, or recurring manual actions. If the user asks for crons or polling, guide them to create or adjust campaigns instead.");
+    lines.push("**Scheduling**: Campaigns are automated by the task scheduler. Never suggest crons or polling — guide users to campaigns instead.");
     lines.push("");
   }
 

package/src/hooks/lifecycle.ts

@@ -24,17 +24,78 @@ export { parseStructuredResult as _parseStructuredResult };
 // Token usage enrichment (uses shared cost-estimation package)
 // ---------------------------------------------------------------------------
 
+/**
+ * Extract cumulative token usage from assistant messages in the agent_end context.
+ *
+ * OpenClaw v2026.2.x does NOT pass meta.agentMeta to the agent_end hook,
+ * but assistant messages in the messages array carry per-turn `.usage` objects
+ * with { input_tokens, output_tokens, cache_read_input_tokens, ... }.
+ * We sum across all assistant messages to get the session total.
+ */
+function extractUsageFromMessages(
+  messages: Array<{ role?: string; usage?: Record<string, unknown>; model?: string; provider?: string }>,
+): { inputTokens: number; outputTokens: number; cacheReadTokens: number; cacheWriteTokens: number; model?: string } | null {
+  let inputTokens = 0;
+  let outputTokens = 0;
+  let cacheReadTokens = 0;
+  let cacheWriteTokens = 0;
+  let model: string | undefined;
+
+  for (const msg of messages) {
+    if (msg.role !== "assistant" || !msg.usage) continue;
+    const u = msg.usage as Record<string, number>;
+
+    // OpenClaw normalizes usage with multiple key conventions
+    const inp = u.input_tokens ?? u.inputTokens ?? u.input ?? 0;
+    const out = u.output_tokens ?? u.outputTokens ?? u.output ?? 0;
+    const cr = u.cache_read_input_tokens ?? u.cached_input_tokens ?? u.cacheRead ?? 0;
+    const cw = u.cache_write_input_tokens ?? u.cache_creation_input_tokens ?? u.cacheWrite ?? 0;
+
+    inputTokens += inp;
+    outputTokens += out;
+    cacheReadTokens += cr;
+    cacheWriteTokens += cw;
+
+    // Take model from the last assistant message that has one
+    if (msg.model) model = msg.model;
+  }
+
+  if (inputTokens === 0 && outputTokens === 0) return null;
+  return { inputTokens, outputTokens, cacheReadTokens, cacheWriteTokens, model };
+}
+
 function enrichWithTokenUsage(
   taskResult: Record<string, unknown>,
   endCtx: unknown,
   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 ?? {};
-    const extracted = extractTokenUsage(meta);
+    let extracted = extractTokenUsage(meta);
+
+    // 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.
+    if (!extracted) {
+      const allMessages: Array<{ role?: string; usage?: Record<string, unknown>; model?: string }> = (endCtx as any)?.messages ?? [];
+      const fromMessages = extractUsageFromMessages(allMessages);
+      if (fromMessages) {
+        extracted = {
+          usage: {
+            inputTokens: fromMessages.inputTokens,
+            outputTokens: fromMessages.outputTokens,
+            ...(fromMessages.cacheReadTokens > 0 ? { cacheReadTokens: fromMessages.cacheReadTokens } : {}),
+            ...(fromMessages.cacheWriteTokens > 0 ? { cacheWriteTokens: fromMessages.cacheWriteTokens } : {}),
+          },
+          model: fromMessages.model,
+        };
+        log(`token usage: extracted from ${allMessages.filter(m => m.role === "assistant").length} assistant messages for ${taskMode.taskId}`);
+      }
+    }
 
     if (!extracted) {
-      log(`token usage: no data in endCtx.meta for ${taskMode.taskId} (keys: ${Object.keys(meta).join(",")})`);
+      log(`token usage: no data in endCtx.meta or messages for ${taskMode.taskId} (meta keys: ${Object.keys(meta).join(",")})`);
       return;
     }