bereach-openclaw 1.5.4 → 1.5.6

package/README.md

@@ -21,8 +21,11 @@ openclaw plugins install bereach-openclaw
 **Before upgrading:** note your `BEREACH_API_KEY` - uninstall may remove `plugins.entries.bereach-openclaw`.
 
 ```bash
-# 1. Uninstall
+# 1. Uninstall + fully delete (rm prevents stale .old copies causing 401 loops)
 openclaw plugins uninstall bereach-openclaw
+rm -rf /data/.openclaw/extensions/bereach-openclaw*
+rm -rf /data/.openclaw/node_modules/bereach-openclaw
+rm -rf /data/.openclaw/node_modules/bereach
 
 # 2. Reinstall latest
 openclaw plugins install bereach-openclaw
@@ -108,9 +111,9 @@ OpenClaw loads plugins from **two locations**:
 
 If `extensions/bereach-openclaw/` is corrupt or incomplete, you get trim/undefined errors. Fix:
 
-**1. Backup and remove the active extension:**
+**1. Fully remove the active extension** (do NOT rename to `.bak` - OpenClaw loads `.bak`/`.old` copies as duplicate plugins):
 ```bash
-mv /data/.openclaw/extensions/bereach-openclaw /data/.openclaw/extensions/bereach-openclaw.bak.$(date +%s)
+rm -rf /data/.openclaw/extensions/bereach-openclaw*
 ```
 
 **2. Reinstall from npm (inside the container):**

package/node_modules/@bereach/tools/src/definitions.ts

@@ -1428,6 +1428,7 @@ export const definitions: ToolDefinition[] = [
         lifecycleStage: { type: "string", enum: ["contact", "lead", "qualified", "approved", "rejected"], description: "New stage (forward-only, or rejected)." },
         hotScore: { type: "integer", minimum: 0, maximum: 100 },
         qualificationNotes: { type: "string", description: "Agent reasoning for qualification/rejection." },
+        leadBrief: { type: "string", description: "2-3 sentence human-readable lead summary for sales prep. NOT ICP analysis — a cheat sheet: who this person is, what they care about, notable background, conversation hooks." },
         notes: { type: "string" },
         name: { type: "string", description: "Update contact name." },
         profileData: { type: "object", description: "Full LinkedIn profile snapshot (JSON)." },

package/openclaw.plugin.json

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

package/src/commands/connector.ts

@@ -58,6 +58,7 @@ type TaskResult = {
   commentsPosted?: number;
   invitationsAccepted?: number;
   error?: string;
+  reason?: string;
 };
 
 const MIN_POLL_MS = 5000;
@@ -230,13 +231,12 @@ async function isWebhookAvailable(config: ConnectorConfig): Promise<boolean> {
     if (res.status === 401 || res.status === 403) return false;
     if (res.ok || res.status === 405 || res.status === 204) return true;
 
-    // Some gateways don't support OPTIONS - fall back to GET on root
-    const rootRes = await fetch(config.gatewayUrl, {
-      method: "GET",
-      signal: AbortSignal.timeout(3000),
-    });
-    // Gateway is up - assume hooks are available if we have a token
-    return rootRes.ok || rootRes.status === 404;
+    // OPTIONS returned non-2xx/405 (e.g. 404): /hooks/agent doesn't exist.
+    // Don't assume hooks are available just because the gateway root responds.
+    // This prevents a false-positive where the connector keeps dispatching
+    // to a webhook URL that doesn't exist, failing every task with 404.
+    console.log(`[connector] Webhook probe: OPTIONS /hooks/agent returned ${res.status}, hooks not available`);
+    return false;
   } catch {
     return false;
   }
@@ -480,9 +480,18 @@ async function executeOnOpenClaw(
   config: ConnectorConfig,
   task: NonNullable<PullResponse["task"]>,
   webhookAvailable: boolean,
-): Promise<{ result: TaskResult | null; error: string | null }> {
+): Promise<{ result: TaskResult | null; error: string | null; webhookDead?: boolean }> {
   if (webhookAvailable) {
-    return executeViaWebhook(config, task);
+    const res = await executeViaWebhook(config, task);
+    // Detect webhook 404 — hooks endpoint doesn't exist (plugin version mismatch,
+    // gateway restart needed). Fall back to execFile for this task AND signal the
+    // main loop to flip webhookAvailable so subsequent tasks don't keep failing.
+    if (res.error?.startsWith("Webhook HTTP 404")) {
+      console.warn(`[connector] Webhook returned 404, falling back to execFile for task ${task.id}`);
+      const fallback = await executeViaExecFile(task);
+      return { ...fallback, webhookDead: true };
+    }
+    return res;
   }
   console.log(`[connector] Webhook unavailable, falling back to execFile`);
   return executeViaExecFile(task);
@@ -612,6 +621,7 @@ export async function runConnectorLoop(
         );
 
         try {
+          (task as any)._startedAt = Date.now();
           await updateTaskStatus(config, task.id, "accepted");
           await updateTaskStatus(config, task.id, "running");
 
@@ -625,9 +635,9 @@ export async function runConnectorLoop(
           }, watchdogMs);
           watchdogTimer.unref(); // Don't prevent graceful shutdown
 
-          const { result, error } = await Promise.race([
+          const execResult = await Promise.race([
             executeOnOpenClaw(config, task, webhookAvailable),
-            new Promise<{ result: null; error: string }>((resolve) => {
+            new Promise<{ result: null; error: string; webhookDead?: boolean }>((resolve) => {
               const check = setTimeout(() => {
                 if (watchdogFired) {
                   resolve({ result: null, error: `Watchdog: task execution exceeded ${Math.round(watchdogMs / 1000)}s timeout` });
@@ -636,21 +646,36 @@ export async function runConnectorLoop(
               check.unref();
             }),
           ]);
+          const { result, error } = execResult;
+          // If webhook returned 404, disable it for future tasks
+          if (execResult.webhookDead) {
+            console.warn(`[connector] Disabling webhook mode — /hooks/agent not available`);
+            webhookAvailable = false;
+          }
           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}${error ? `: ${error.slice(0, 100)}` : ""}${task.workflowRunId ? ` workflow=${task.workflowRunId}` : ""}`,
+            `[connector] Task ${task.id} ${taskStatus} (${Math.round(execDuration / 1000)}s)${error ? `: ${error.slice(0, 100)}` : ""}${result?.reason ? ` reason=${result.reason}` : ""}${task.workflowRunId ? ` workflow=${task.workflowRunId}` : ""}`,
           );
-
-          // With webhook execution, the lifecycle hook auto-reports results.
-          // Submit from connector for execFile fallback, errors, or as safety net
-          // when lifecycle hook may not have fired (agent crash).
-          // Don't submit if result looks successful — lifecycle hook already posted.
-          if (!webhookAvailable || error) {
-            await submitResult(config, task.id, result, error);
+          // Flag suspicious fast failures with no tools for investigation
+          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 — likely context injection failure or model error`);
           }
 
+          // Always submit from connector as safety net. In webhook mode the lifecycle
+          // hook usually reports first, but if it fails silently (network, crash) the
+          // result is lost and the task stays "running" forever. The result endpoint
+          // uses an optimistic lock so double-submissions are harmless (second is a no-op).
+          // Derive error when result indicates failure but no explicit error exists.
+          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.ts

@@ -374,7 +374,7 @@ function formatCampaignDispatch(
   const shown = Math.min(ranked.length, 7);
   for (let i = 0; i < shown; i++) {
     const { campaign: c } = ranked[i];
-    const pipelineUrl = `${CHAT_BASE}/pipeline?campaign=${c.id}`;
+    const pipelineUrl = `${CHAT_BASE}/campaigns/${c.id}/pipeline`;
     const s = c.stageCounts;
     const funnel = s && (s.lead || s.qualified || s.approved || s.rejected)
       ? ` — ${s.lead ?? 0}L / ${s.qualified ?? 0}Q / ${s.approved ?? 0}A / ${s.rejected ?? 0}R`
@@ -479,7 +479,7 @@ function formatOnboardingDirective(state: SessionState, data: CacheStore, apiKey
       "",
       "Search 5 matching prospects, visit top 3. Present: name, title, company, why they fit, suggested approach.",
       "Offer first action: connect, warm up (like/comment), or save to campaign.",
-      "Execute, then link: [Pipeline](${CHAT_BASE}/pipeline) / [Campaigns](${CHAT_BASE}/campaigns)",
+      "Execute, then link: [Campaigns](${CHAT_BASE}/campaigns)",
       '- `bereach_state_patch({ key: "onboarding", data: { quickWinDone: true } })`',
       "",
     );
@@ -576,7 +576,7 @@ function formatLiveStatus(state: SessionState, data: CacheStore, apiKey?: string
       lines.push("");
     }
     lines.push("### Dashboard Links");
-    lines.push(`[Pipeline](${CHAT_BASE}/pipeline) | [Campaigns](${CHAT_BASE}/campaigns) | [Drafts](${CHAT_BASE}/drafts) | [Context](${CHAT_BASE}/context) | [Settings](${CHAT_BASE}/settings) | [Pricing](${PRICING_URL})`);
+    lines.push(`[Campaigns](${CHAT_BASE}/campaigns) | [Activity](${CHAT_BASE}/activity) | [Context](${CHAT_BASE}/context) | [Settings](${CHAT_BASE}/settings) | [Pricing](${PRICING_URL})`);
     lines.push("");
     log(`live-status: ONBOARDING mode (${lines.join("\n").length} chars)`);
     return lines.join("\n");
@@ -733,7 +733,7 @@ function formatLiveStatus(state: SessionState, data: CacheStore, apiKey?: string
   if (upgradeBlock) lines.push(upgradeBlock);
 
   // Dashboard links
-  lines.push(`**Links**: [Pipeline](${CHAT_BASE}/pipeline) | [Campaigns](${CHAT_BASE}/campaigns) | [Drafts](${CHAT_BASE}/drafts) | [Context](${CHAT_BASE}/context) | [Settings](${CHAT_BASE}/settings) | [Pricing](${PRICING_URL})`);
+  lines.push(`**Links**: [Campaigns](${CHAT_BASE}/campaigns) | [Activity](${CHAT_BASE}/activity) | [Context](${CHAT_BASE}/context) | [Settings](${CHAT_BASE}/settings) | [Pricing](${PRICING_URL})`);
   lines.push("");
 
   log(`live-status: ACTIVE mode, campaigns=${hasCampaigns} contacts=${hasContacts} pending=${data.pendingDrafts > 0 || data.failedDrafts > 0 || data.unreadDMs > 0} (${lines.join("\n").length} chars)`);

package/src/hooks/lifecycle.ts

@@ -125,9 +125,25 @@ export function registerLifecycleHook(
           creditsUsed: state.creditsUsedThisSession,
           toolCallCount: state.toolCallCount,
           visitCount: state.visitCount,
-          ...(state.toolCallCount === 0 ? { reason: "no_tools_called" } : {}),
+          ...(state.toolCallCount === 0 ? { reason: "no_tools_called", error: "Task completed with no tool calls" } : {}),
         };
 
+        // Diagnostic logging for no_tools_called — capture WHY the agent did nothing.
+        // This helps diagnose context injection failures, model errors, etc.
+        if (state.toolCallCount === 0) {
+          const msgCount = allMessages.length;
+          const userMsgCount = userMsgs.length;
+          const assistantMsgCount = assistantMsgs.length;
+          const lastAssistantText = outputText?.slice(0, 300) || "(empty)";
+          const hasTaskMeta = userMsgs.some((m: any) => extractTextFromContent(m.content).includes("TASK_META"));
+          const endSuccess = (endCtx as any)?.success;
+          const endError = (endCtx as any)?.error;
+          log(`NO_TOOLS_CALLED diagnostic for ${taskMode.taskId}: ` +
+            `msgs=${msgCount} (user=${userMsgCount} assistant=${assistantMsgCount}) ` +
+            `hasTaskMeta=${hasTaskMeta} endSuccess=${endSuccess} endError=${endError ? String(endError).slice(0, 200) : "none"} ` +
+            `lastAssistant="${lastAssistantText}"`);
+        }
+
         // B17 fix: In execFile mode, the connector also submits results after
         // parsing the OpenClaw --json wrapper (extractTaskResultFromWrapper).
         // The lifecycle hook fires first (inside subprocess), so it wins the race.
@@ -148,10 +164,14 @@ export function registerLifecycleHook(
           attempts++;
           try {
             if (attempt > 0) await new Promise((r) => setTimeout(r, 2000 * attempt));
+            // Derive error from result when task failed but no explicit error exists
+            const taskError = taskResult.success === false
+              ? (taskResult.error ?? taskResult.reason ?? "Task failed (no details captured)")
+              : undefined;
             const res = await fetch(`${API_BASE}/tasks/${taskMode.taskId}/result`, {
               method: "POST",
               headers: { Authorization: `Bearer ${key}`, "Content-Type": "application/json" },
-              body: JSON.stringify({ result: taskResult }),
+              body: JSON.stringify({ result: taskResult, ...(taskError ? { error: taskError } : {}) }),
               signal: AbortSignal.timeout(10000),
             });
             if (res.ok) {

package/src/index.ts

@@ -17,6 +17,10 @@ const log = createLogger("init");
 /** Guard against multiple register() calls with the same api instance */
 const registeredApis = new WeakSet<object>();
 let registeredCount = 0;
+let autoDetectDone = false;
+let lastRegisterAt = 0;
+/** After initial burst, suppress noisy re-registration logs */
+const REGISTER_LOG_THRESHOLD = 5;
 
 /**
  * Resolve the BeReach API key from all supported sources (in priority order):
@@ -32,6 +36,86 @@ export function resolveApiKey(api: any): string | undefined {
   return typeof key === "string" && key.trim().length > 0 ? key.trim() : undefined;
 }
 
+/**
+ * Auto-detect LLM provider from available API keys and set workspace defaults.
+ *
+ * Runs once at install time. If the workspace still has Anthropic defaults but
+ * no ANTHROPIC_API_KEY is available (only GEMINI_API_KEY), switches to Gemini
+ * models automatically. This prevents tasks from failing because the default
+ * models require an API key the user doesn't have.
+ *
+ * Does nothing if:
+ * - Already ran this session (idempotent guard)
+ * - ANTHROPIC_API_KEY is available (defaults are correct)
+ * - No GEMINI_API_KEY available (nothing to switch to)
+ * - User already changed models from defaults (respects manual choice)
+ */
+async function autoDetectModels(apiKey: string): Promise<void> {
+  if (autoDetectDone) return;
+  autoDetectDone = true;
+
+  const hasAnthropic = !!readEnv("ANTHROPIC_API_KEY");
+  const hasGemini = !!(readEnv("GEMINI_API_KEY") || readEnv("GOOGLE_API_KEY"));
+
+  // If Anthropic key exists, defaults are already correct
+  if (hasAnthropic) {
+    log("model auto-detect: Anthropic key available, keeping defaults");
+    return;
+  }
+
+  // If no Gemini key either, nothing we can switch to
+  if (!hasGemini) {
+    log("model auto-detect: no LLM provider keys found, skipping");
+    return;
+  }
+
+  // Gemini key available, no Anthropic key - check if we need to switch
+  try {
+    const res = await fetch(`${API_BASE}/me/settings`, {
+      headers: { Authorization: `Bearer ${apiKey}` },
+      signal: AbortSignal.timeout(5000),
+    });
+    if (!res.ok) {
+      log(`model auto-detect: settings GET failed (HTTP ${res.status}), skipping`);
+      return;
+    }
+
+    const data = await res.json() as {
+      aiModels?: { fast?: string; creative?: string };
+    };
+    const currentFast = data.aiModels?.fast;
+    const currentCreative = data.aiModels?.creative;
+
+    // Only auto-switch if still on Anthropic defaults (respect manual choices)
+    if (
+      currentFast === "anthropic/claude-haiku-4-5" &&
+      currentCreative === "anthropic/claude-sonnet-4-6"
+    ) {
+      const patchRes = await fetch(`${API_BASE}/me/settings`, {
+        method: "PATCH",
+        headers: {
+          Authorization: `Bearer ${apiKey}`,
+          "Content-Type": "application/json",
+        },
+        body: JSON.stringify({
+          aiFastModel: "google/gemini-2.5-flash",
+          aiCreativeModel: "google/gemini-2.5-pro",
+        }),
+        signal: AbortSignal.timeout(5000),
+      });
+      if (patchRes.ok) {
+        log("model auto-detect: no Anthropic key, Gemini key found - switched to Gemini Flash (fast) + Gemini Pro (creative)");
+      } else {
+        log(`model auto-detect: PATCH failed (HTTP ${patchRes.status})`);
+      }
+    } else {
+      log("model auto-detect: models already customized, skipping");
+    }
+  } catch (err) {
+    log(`model auto-detect: ${err instanceof Error ? err.message : String(err)}`);
+  }
+}
+
 export default function register(api: any) {
   if (api && typeof api === "object" && registeredApis.has(api)) {
     log(`skip duplicate register() call (same api instance, call #${registeredCount + 1})`);
@@ -39,8 +123,11 @@ export default function register(api: any) {
   }
 
   registeredCount++;
-  if (registeredCount > 1) {
+  lastRegisterAt = Date.now();
+  if (registeredCount > 1 && registeredCount <= REGISTER_LOG_THRESHOLD) {
     log(`register() called again (call #${registeredCount}) — re-registering on new api instance`);
+  } else if (registeredCount === REGISTER_LOG_THRESHOLD + 1) {
+    log(`register() call #${registeredCount} — suppressing further re-registration logs`);
   }
   if (api && typeof api === "object") {
     registeredApis.add(api);
@@ -127,6 +214,15 @@ export default function register(api: any) {
     }
   }
 
+  // Auto-detect LLM provider and set workspace model defaults.
+  // Runs before connector start so tasks use the correct models from the first poll.
+  // Fire-and-forget — non-critical, must not block registration.
+  if (apiKey) {
+    autoDetectModels(apiKey).catch((err) => {
+      log(`model auto-detect error: ${err instanceof Error ? err.message : String(err)}`);
+    });
+  }
+
   // Auto-start connector if API key is present and connector is enabled.
   // Skip when running as an agent child process (openclaw agent) — each child
   // would start its own polling loop, stealing tasks from the main connector.

package/src/tools/index.ts

@@ -155,6 +155,7 @@ export function registerAllTools(api: any, taskType?: string) {
               content: [{ type: "text" as const, text: JSON.stringify({ success: false, error: "Invalid key format. Must start with brc_. Get your key at https://bereach.ai/token" }) }],
             };
           }
+
           if (typeof api?.config?.set !== "function") {
             return {
               content: [{ type: "text" as const, text: JSON.stringify({ success: false, error: "Config API not available. Set BEREACH_API_KEY as an environment variable instead." }) }],