@bubblelab/bubble-core 0.1.150 → 0.1.152

package/dist/bubbles/tool-bubble/browser-tools/_shared/ai/ai-fallback-step.js

@@ -0,0 +1,77 @@
+import { AIBrowserAgent } from './ai-browser-agent.js';
+/**
+ * Lightweight decorator that wraps a method with AI fallback error recovery.
+ * This is the OSS-compatible version of @RecordableStep — no recording,
+ * just AI-powered recovery when selectors/actions fail.
+ *
+ * When the decorated method throws, the decorator:
+ * 1. Creates an AIBrowserAgent with the active session
+ * 2. If extractionSchema is provided: uses AI vision to extract data
+ * 3. Otherwise: asks AI to suggest a recovery action (click, type, scroll, etc.)
+ * 4. Executes the suggested action
+ * 5. For wait/scroll: retries the original method
+ * 6. For click/type/click_coordinates: returns true (action completed)
+ *
+ * @param stepName - Human-readable name for logging
+ * @param options - Task description and optional extraction schema
+ */
+export function AIFallbackStep(stepName, options = {}) {
+    return function (originalMethod, _context) {
+        return async function (...args) {
+            try {
+                return await originalMethod.apply(this, args);
+            }
+            catch (error) {
+                const self = this;
+                const errorMsg = error instanceof Error ? error.message : String(error);
+                const sessionId = self.sessionId;
+                if (!sessionId)
+                    throw error;
+                const aiAgent = new AIBrowserAgent({
+                    sessionId,
+                    context: self.context,
+                    credentials: self.params?.credentials,
+                });
+                const taskDesc = options.taskDescription || stepName;
+                if (options.extractionSchema) {
+                    console.log(`[AIFallback] Extracting data for "${stepName}"`);
+                    const extracted = await aiAgent.extractData(options.extractionSchema, taskDesc);
+                    if (extracted !== null) {
+                        console.log(`[AIFallback] Extraction succeeded for "${stepName}"`);
+                        return extracted;
+                    }
+                }
+                else {
+                    console.log(`[AIFallback] Suggesting recovery for "${stepName}"`);
+                    const action = await aiAgent.suggestRecoveryAction(taskDesc, errorMsg);
+                    console.log(`[AIFallback] AI suggested:`, action);
+                    if (action.action !== 'none') {
+                        const success = await aiAgent.executeAction(action);
+                        if (success) {
+                            if (action.action === 'wait' || action.action === 'scroll') {
+                                console.log(`[AIFallback] Retrying "${stepName}" after ${action.action}`);
+                                try {
+                                    return await originalMethod.apply(this, args);
+                                }
+                                catch (retryError) {
+                                    console.log(`[AIFallback] Retry failed for "${stepName}":`, retryError);
+                                }
+                            }
+                            else if (action.action === 'click' ||
+                                action.action === 'type' ||
+                                action.action === 'click_coordinates') {
+                                console.log(`[AIFallback] Action completed for "${stepName}"`);
+                                return true;
+                            }
+                        }
+                    }
+                    else {
+                        console.log(`[AIFallback] AI could not help: ${action.reason}`);
+                    }
+                }
+                throw error;
+            }
+        };
+    };
+}
+//# sourceMappingURL=ai-fallback-step.js.map

package/dist/bubbles/tool-bubble/browser-tools/_shared/ai/ai-fallback-step.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ai-fallback-step.js","sourceRoot":"","sources":["../../../../../../src/bubbles/tool-bubble/browser-tools/_shared/ai/ai-fallback-step.ts"],"names":[],"mappings":"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"}

package/dist/bubbles/tool-bubble/browser-tools/_shared/ai/index.d.ts

@@ -0,0 +1,4 @@
+export { AIBrowserAgent } from './ai-browser-agent.js';
+export { AIFallbackStep } from './ai-fallback-step.js';
+export type { AIBrowserAction, AIBrowserAgentConfig, } from './ai-browser-agent.types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/bubbles/tool-bubble/browser-tools/_shared/ai/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/bubbles/tool-bubble/browser-tools/_shared/ai/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AACvD,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AACvD,YAAY,EACV,eAAe,EACf,oBAAoB,GACrB,MAAM,6BAA6B,CAAC"}

package/dist/bubbles/tool-bubble/browser-tools/_shared/ai/index.js

@@ -0,0 +1,3 @@
+export { AIBrowserAgent } from './ai-browser-agent.js';
+export { AIFallbackStep } from './ai-fallback-step.js';
+//# sourceMappingURL=index.js.map

package/dist/bubbles/tool-bubble/browser-tools/_shared/ai/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../../src/bubbles/tool-bubble/browser-tools/_shared/ai/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AACvD,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC"}

package/dist/bubbles/tool-bubble/browser-tools/linkedin-accept-invitations/tool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../../../../src/bubbles/tool-bubble/browser-tools/linkedin-accept-invitations/tool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,wCAAwC,CAAC;AACpE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAKjE,OAAO,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAE3D,OAAO,EAGL,KAAK,wCAAwC,EAC7C,KAAK,mCAAmC,EAEzC,MAAM,aAAa,CAAC;AAErB,qBAAa,6BAA6B,CACxC,CAAC,SACC,wCAAwC,GAAG,wCAAwC,CACrF,SAAQ,UAAU,CAAC,CAAC,EAAE,mCAAmC,CAAC;IAC1D,MAAM,CAAC,QAAQ,CAAC,UAAU,EAAG,kCAAkC,CAAU;IACzE,MAAM,CAAC,QAAQ,CAAC,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAA6C;IACnE,MAAM,CAAC,QAAQ,CAAC,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAA6C;IACzE,MAAM,CAAC,QAAQ,CAAC,gBAAgB,kDACiB;IACjD,MAAM,CAAC,QAAQ,CAAC,eAAe,mIACmG;IAClI,MAAM,CAAC,QAAQ,CAAC,KAAK,iCAAiC;IACtD,MAAM,CAAC,QAAQ,CAAC,IAAI,UAAU;IAE9B,OAAO,CAAC,SAAS,CAAuB;IACxC,OAAO,CAAC,SAAS,CAAuB;IACxC,OAAO,CAAC,OAAO,CAA4B;gBAGzC,MAAM,GAAE,CAA4C,EACpD,OAAO,CAAC,EAAE,aAAa;IAKzB,SAAS,CAAC,gBAAgB,IAAI,MAAM,GAAG,SAAS;YAOlC,uBAAuB;YAgCvB,+BAA+B;YAkB/B,0BAA0B;YAqB1B,wBAAwB;YA2NxB,qBAAqB;YAYrB,QAAQ;YAaR,eAAe;IAiBvB,aAAa,IAAI,OAAO,CAAC,mCAAmC,CAAC;CAyCpE"}
+{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../../../../src/bubbles/tool-bubble/browser-tools/linkedin-accept-invitations/tool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,wCAAwC,CAAC;AACpE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAMjE,OAAO,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAE3D,OAAO,EAGL,KAAK,wCAAwC,EAC7C,KAAK,mCAAmC,EAEzC,MAAM,aAAa,CAAC;AAErB,qBAAa,6BAA6B,CACxC,CAAC,SACC,wCAAwC,GAAG,wCAAwC,CACrF,SAAQ,UAAU,CAAC,CAAC,EAAE,mCAAmC,CAAC;IAC1D,MAAM,CAAC,QAAQ,CAAC,UAAU,EAAG,kCAAkC,CAAU;IACzE,MAAM,CAAC,QAAQ,CAAC,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAA6C;IACnE,MAAM,CAAC,QAAQ,CAAC,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAA6C;IACzE,MAAM,CAAC,QAAQ,CAAC,gBAAgB,kDACiB;IACjD,MAAM,CAAC,QAAQ,CAAC,eAAe,mIACmG;IAClI,MAAM,CAAC,QAAQ,CAAC,KAAK,iCAAiC;IACtD,MAAM,CAAC,QAAQ,CAAC,IAAI,UAAU;IAE9B,OAAO,CAAC,SAAS,CAAuB;IACxC,OAAO,CAAC,SAAS,CAAuB;IACxC,OAAO,CAAC,OAAO,CAA4B;gBAGzC,MAAM,GAAE,CAA4C,EACpD,OAAO,CAAC,EAAE,aAAa;IAKzB,SAAS,CAAC,gBAAgB,IAAI,MAAM,GAAG,SAAS;YAOlC,uBAAuB;YAmCvB,+BAA+B;YAsB/B,0BAA0B;YAyB1B,wBAAwB;YA2NxB,qBAAqB;YAYrB,QAAQ;YAaR,eAAe;IAiBvB,aAAa,IAAI,OAAO,CAAC,mCAAmC,CAAC;CAyCpE"}

package/dist/bubbles/tool-bubble/browser-tools/linkedin-accept-invitations/tool.js

@@ -1,72 +1,129 @@
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
 import { ToolBubble } from '../../../../types/tool-bubble-class.js';
+import { AIFallbackStep } from '../_shared/ai/ai-fallback-step.js';
 import { BrowserBaseBubble, } from '../../../service-bubble/browserbase/index.js';
 import { CredentialType } from '@bubblelab/shared-schemas';
 import { parseBrowserSessionData, buildProxyConfig } from '../_shared/utils.js';
 import { LinkedInAcceptInvitationsToolParamsSchema, LinkedInAcceptInvitationsToolResultSchema, } from './schema.js';
-export class LinkedInAcceptInvitationsTool extends ToolBubble {
-    static bubbleName = 'linkedin-accept-invitations-tool';
-    static schema = LinkedInAcceptInvitationsToolParamsSchema;
-    static resultSchema = LinkedInAcceptInvitationsToolResultSchema;
-    static shortDescription = 'Accept top N LinkedIn connection invitations';
-    static longDescription = 'Recordable tool that navigates to the LinkedIn invitation manager page and accepts the top N received connection invitations.';
-    static alias = 'linkedin-accept-invitations';
-    static type = 'tool';
-    sessionId = null;
-    contextId = null;
-    cookies = null;
-    constructor(params = { operation: 'accept_invitations' }, context) {
-        super(params, context);
-    }
-    chooseCredential() {
-        const { credentials } = this.params;
-        return credentials?.[CredentialType.LINKEDIN_CRED];
-    }
-    async stepStartBrowserSession() {
-        if (this.sessionId)
-            return;
-        const sessionData = parseBrowserSessionData(this.chooseCredential());
-        if (sessionData) {
-            this.contextId = sessionData.contextId;
-            this.cookies = sessionData.cookies;
+let LinkedInAcceptInvitationsTool = (() => {
+    let _classSuper = ToolBubble;
+    let _instanceExtraInitializers = [];
+    let _stepNavigateToInvitationManager_decorators;
+    let _stepWaitForInvitationsPage_decorators;
+    let _stepAcceptTopInvitations_decorators;
+    return class LinkedInAcceptInvitationsTool extends _classSuper {
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            _stepNavigateToInvitationManager_decorators = [AIFallbackStep('Navigate to invitation manager', {
+                    taskDescription: 'Navigate to the LinkedIn invitation manager page',
+                })];
+            _stepWaitForInvitationsPage_decorators = [AIFallbackStep('Wait for invitations to load', {
+                    taskDescription: 'Wait for the received invitations list to fully load with Accept buttons',
+                })];
+            _stepAcceptTopInvitations_decorators = [AIFallbackStep('Accept top invitations', {
+                    taskDescription: 'Click Accept on the top N connection invitations and extract their info',
+                })];
+            __esDecorate(this, null, _stepNavigateToInvitationManager_decorators, { kind: "method", name: "stepNavigateToInvitationManager", static: false, private: false, access: { has: obj => "stepNavigateToInvitationManager" in obj, get: obj => obj.stepNavigateToInvitationManager }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _stepWaitForInvitationsPage_decorators, { kind: "method", name: "stepWaitForInvitationsPage", static: false, private: false, access: { has: obj => "stepWaitForInvitationsPage" in obj, get: obj => obj.stepWaitForInvitationsPage }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _stepAcceptTopInvitations_decorators, { kind: "method", name: "stepAcceptTopInvitations", static: false, private: false, access: { has: obj => "stepAcceptTopInvitations" in obj, get: obj => obj.stepAcceptTopInvitations }, metadata: _metadata }, null, _instanceExtraInitializers);
+            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
         }
-        const proxyConfig = buildProxyConfig(this.params.proxy);
-        const browserbase = new BrowserBaseBubble({
-            operation: 'start_session',
-            context_id: this.contextId || undefined,
-            cookies: this.cookies || undefined,
-            credentials: this.params.credentials,
-            stealth: { solveCaptchas: true },
-            timeout_seconds: 1200,
-            ...proxyConfig,
-        }, this.context, 'startsession');
-        const result = await browserbase.action();
-        if (!result.data.success || !result.data.session_id) {
-            throw new Error(result.data.error || 'Failed to start browser session');
+        static bubbleName = 'linkedin-accept-invitations-tool';
+        static schema = LinkedInAcceptInvitationsToolParamsSchema;
+        static resultSchema = LinkedInAcceptInvitationsToolResultSchema;
+        static shortDescription = 'Accept top N LinkedIn connection invitations';
+        static longDescription = 'Recordable tool that navigates to the LinkedIn invitation manager page and accepts the top N received connection invitations.';
+        static alias = 'linkedin-accept-invitations';
+        static type = 'tool';
+        sessionId = (__runInitializers(this, _instanceExtraInitializers), null);
+        contextId = null;
+        cookies = null;
+        constructor(params = { operation: 'accept_invitations' }, context) {
+            super(params, context);
         }
-        this.sessionId = result.data.session_id;
-        if (result.data.context_id)
-            this.contextId = result.data.context_id;
-        console.log(`[AcceptInvitations] Session started: ${this.sessionId}`);
-        const ip = await this.detectIPAddress();
-        if (ip)
-            console.log(`[AcceptInvitations] Browser IP: ${ip}`);
-    }
-    async stepNavigateToInvitationManager() {
-        if (!this.sessionId)
-            throw new Error('No active session');
-        const browserbase = new BrowserBaseBubble({
-            operation: 'navigate',
-            session_id: this.sessionId,
-            url: 'https://www.linkedin.com/mynetwork/invitation-manager/',
-            wait_until: 'domcontentloaded',
-            timeout: 30000,
-        }, this.context, 'navigate');
-        const result = await browserbase.action();
-        if (!result.data.success)
-            throw new Error(result.data.error || 'Navigation failed');
-    }
-    async stepWaitForInvitationsPage() {
-        const checkScript = `(() => {
+        chooseCredential() {
+            const { credentials } = this.params;
+            return credentials?.[CredentialType.LINKEDIN_CRED];
+        }
+        async stepStartBrowserSession() {
+            if (this.sessionId)
+                return;
+            const sessionData = parseBrowserSessionData(this.chooseCredential());
+            if (sessionData) {
+                this.contextId = sessionData.contextId;
+                this.cookies = sessionData.cookies;
+            }
+            const proxyConfig = buildProxyConfig(this.params.proxy);
+            const browserbase = new BrowserBaseBubble({
+                operation: 'start_session',
+                context_id: this.contextId || undefined,
+                cookies: this.cookies || undefined,
+                credentials: this.params.credentials,
+                stealth: { solveCaptchas: true },
+                timeout_seconds: 1200,
+                ...proxyConfig,
+            }, this.context, 'startsession');
+            const result = await browserbase.action();
+            if (!result.data.success || !result.data.session_id) {
+                throw new Error(result.data.error || 'Failed to start browser session');
+            }
+            this.sessionId = result.data.session_id;
+            if (result.data.context_id)
+                this.contextId = result.data.context_id;
+            console.log(`[AcceptInvitations] Session started: ${this.sessionId}`);
+            const ip = await this.detectIPAddress();
+            if (ip)
+                console.log(`[AcceptInvitations] Browser IP: ${ip}`);
+        }
+        async stepNavigateToInvitationManager() {
+            if (!this.sessionId)
+                throw new Error('No active session');
+            const browserbase = new BrowserBaseBubble({
+                operation: 'navigate',
+                session_id: this.sessionId,
+                url: 'https://www.linkedin.com/mynetwork/invitation-manager/',
+                wait_until: 'domcontentloaded',
+                timeout: 30000,
+            }, this.context, 'navigate');
+            const result = await browserbase.action();
+            if (!result.data.success)
+                throw new Error(result.data.error || 'Navigation failed');
+        }
+        async stepWaitForInvitationsPage() {
+            const checkScript = `(() => {
       const buttons = document.querySelectorAll('button');
       let hasAcceptButton = false;
       for (const btn of buttons) {
@@ -78,25 +135,25 @@ export class LinkedInAcceptInvitationsTool extends ToolBubble {
       const peopleLabel = document.body.innerText.match(/People\\s*\\(\\d+\\)/i);
       return hasAcceptButton || !!peopleLabel;
     })()`;
-        for (let attempt = 1; attempt <= 15; attempt++) {
-            const found = await this.evaluate(checkScript);
-            if (found)
-                return true;
-            await new Promise((r) => setTimeout(r, 1000));
+            for (let attempt = 1; attempt <= 15; attempt++) {
+                const found = await this.evaluate(checkScript);
+                if (found)
+                    return true;
+                await new Promise((r) => setTimeout(r, 1000));
+            }
+            return false;
         }
-        return false;
-    }
-    async stepAcceptTopInvitations() {
-        const count = this.params.count ?? 5;
-        const accepted = [];
-        let skipped = 0;
-        let availableCount = 0;
-        const TEMP_ID = '__bubblelab_accept_target__';
-        const MAX_CLICK_RETRIES = 2;
-        const POST_ACCEPT_SETTLE_MS = 1500;
-        for (let i = 0; i < count; i++) {
-            // Step 1: Find first visible Accept button, extract card info, tag it with a temp ID
-            const extractResult = (await this.evaluate(`
+        async stepAcceptTopInvitations() {
+            const count = this.params.count ?? 5;
+            const accepted = [];
+            let skipped = 0;
+            let availableCount = 0;
+            const TEMP_ID = '__bubblelab_accept_target__';
+            const MAX_CLICK_RETRIES = 2;
+            const POST_ACCEPT_SETTLE_MS = 1500;
+            for (let i = 0; i < count; i++) {
+                // Step 1: Find first visible Accept button, extract card info, tag it with a temp ID
+                const extractResult = (await this.evaluate(`
         (() => {
           // Clean up any previous temp ID
           const prev = document.getElementById('${TEMP_ID}');
@@ -203,24 +260,24 @@ export class LinkedInAcceptInvitationsTool extends ToolBubble {
           };
         })()
       `));
-            if (extractResult.done) {
-                console.log(`[AcceptInvitations] No more invitations to accept after ${accepted.length}`);
-                break;
-            }
-            // Track available invitations on first iteration
-            if (i === 0)
-                availableCount = extractResult.buttonCount;
-            const prevButtonCount = extractResult.buttonCount;
-            // Step 2: Click the tagged button with retries (re-tag on failure)
-            if (!this.sessionId)
-                throw new Error('No active session');
-            let clickSucceeded = false;
-            for (let retry = 0; retry <= MAX_CLICK_RETRIES; retry++) {
-                // On retry, wait for DOM to settle then re-tag the button
-                if (retry > 0) {
-                    console.log(`[AcceptInvitations] Retrying click for invitation ${i + 1} (attempt ${retry + 1})`);
-                    await new Promise((r) => setTimeout(r, 1500));
-                    await this.evaluate(`
+                if (extractResult.done) {
+                    console.log(`[AcceptInvitations] No more invitations to accept after ${accepted.length}`);
+                    break;
+                }
+                // Track available invitations on first iteration
+                if (i === 0)
+                    availableCount = extractResult.buttonCount;
+                const prevButtonCount = extractResult.buttonCount;
+                // Step 2: Click the tagged button with retries (re-tag on failure)
+                if (!this.sessionId)
+                    throw new Error('No active session');
+                let clickSucceeded = false;
+                for (let retry = 0; retry <= MAX_CLICK_RETRIES; retry++) {
+                    // On retry, wait for DOM to settle then re-tag the button
+                    if (retry > 0) {
+                        console.log(`[AcceptInvitations] Retrying click for invitation ${i + 1} (attempt ${retry + 1})`);
+                        await new Promise((r) => setTimeout(r, 1500));
+                        await this.evaluate(`
             (() => {
               const prev = document.getElementById('${TEMP_ID}');
               if (prev) prev.removeAttribute('id');
@@ -234,70 +291,70 @@ export class LinkedInAcceptInvitationsTool extends ToolBubble {
               return true;
             })()
           `);
+                    }
+                    const clickBubble = new BrowserBaseBubble({
+                        operation: 'click',
+                        session_id: this.sessionId,
+                        selector: `#${TEMP_ID}`,
+                        wait_for_navigation: false,
+                        timeout: 5000,
+                    }, this.context, 'clickaccept');
+                    const clickResult = await clickBubble.action();
+                    if (clickResult.data.success) {
+                        clickSucceeded = true;
+                        break;
+                    }
                 }
-                const clickBubble = new BrowserBaseBubble({
-                    operation: 'click',
-                    session_id: this.sessionId,
-                    selector: `#${TEMP_ID}`,
-                    wait_for_navigation: false,
-                    timeout: 5000,
-                }, this.context, 'clickaccept');
-                const clickResult = await clickBubble.action();
-                if (clickResult.data.success) {
-                    clickSucceeded = true;
-                    break;
+                if (!clickSucceeded) {
+                    console.log(`[AcceptInvitations] Click failed for invitation ${i + 1} after ${MAX_CLICK_RETRIES + 1} attempts, skipping`);
+                    skipped++;
+                    await new Promise((r) => setTimeout(r, 1000));
+                    continue;
                 }
-            }
-            if (!clickSucceeded) {
-                console.log(`[AcceptInvitations] Click failed for invitation ${i + 1} after ${MAX_CLICK_RETRIES + 1} attempts, skipping`);
-                skipped++;
-                await new Promise((r) => setTimeout(r, 1000));
-                continue;
-            }
-            if (extractResult.info) {
-                accepted.push(extractResult.info);
-                console.log(`[AcceptInvitations] Accepted ${i + 1}/${count}: ${extractResult.info.name}`);
-            }
-            // Step 3: Wait for DOM to update — poll until Accept button count decreases
-            const MAX_WAIT_POLLS = 15;
-            for (let poll = 0; poll < MAX_WAIT_POLLS; poll++) {
-                await new Promise((r) => setTimeout(r, 500));
-                const currentCount = (await this.evaluate(`
+                if (extractResult.info) {
+                    accepted.push(extractResult.info);
+                    console.log(`[AcceptInvitations] Accepted ${i + 1}/${count}: ${extractResult.info.name}`);
+                }
+                // Step 3: Wait for DOM to update — poll until Accept button count decreases
+                const MAX_WAIT_POLLS = 15;
+                for (let poll = 0; poll < MAX_WAIT_POLLS; poll++) {
+                    await new Promise((r) => setTimeout(r, 500));
+                    const currentCount = (await this.evaluate(`
           Array.from(document.querySelectorAll('button')).filter(btn => {
             const text = (btn.innerText || btn.textContent || '').trim().toLowerCase();
             return text === 'accept' && btn.offsetParent !== null && !btn.disabled;
           }).length
         `));
-                if (currentCount < prevButtonCount)
-                    break;
+                    if (currentCount < prevButtonCount)
+                        break;
+                }
+                // Extra settle time for LinkedIn UI animations before next iteration
+                await new Promise((r) => setTimeout(r, POST_ACCEPT_SETTLE_MS));
             }
-            // Extra settle time for LinkedIn UI animations before next iteration
-            await new Promise((r) => setTimeout(r, POST_ACCEPT_SETTLE_MS));
+            return { accepted, skipped, availableCount };
         }
-        return { accepted, skipped, availableCount };
-    }
-    async stepEndBrowserSession() {
-        if (!this.sessionId)
-            return;
-        const browserbase = new BrowserBaseBubble({ operation: 'end_session', session_id: this.sessionId }, this.context, 'endsession');
-        await browserbase.action();
-        console.log(`[AcceptInvitations] Session ended: ${this.sessionId}`);
-        this.sessionId = null;
-    }
-    async evaluate(script) {
-        if (!this.sessionId)
-            throw new Error('No active session');
-        const browserbase = new BrowserBaseBubble({ operation: 'evaluate', session_id: this.sessionId, script }, this.context, 'evaluate');
-        const result = await browserbase.action();
-        if (!result.data.success)
-            throw new Error(result.data.error || 'Evaluation failed');
-        return result.data.result;
-    }
-    async detectIPAddress() {
-        if (!this.sessionId)
-            return null;
-        try {
-            return (await this.evaluate(`
+        async stepEndBrowserSession() {
+            if (!this.sessionId)
+                return;
+            const browserbase = new BrowserBaseBubble({ operation: 'end_session', session_id: this.sessionId }, this.context, 'endsession');
+            await browserbase.action();
+            console.log(`[AcceptInvitations] Session ended: ${this.sessionId}`);
+            this.sessionId = null;
+        }
+        async evaluate(script) {
+            if (!this.sessionId)
+                throw new Error('No active session');
+            const browserbase = new BrowserBaseBubble({ operation: 'evaluate', session_id: this.sessionId, script }, this.context, 'evaluate');
+            const result = await browserbase.action();
+            if (!result.data.success)
+                throw new Error(result.data.error || 'Evaluation failed');
+            return result.data.result;
+        }
+        async detectIPAddress() {
+            if (!this.sessionId)
+                return null;
+            try {
+                return (await this.evaluate(`
         (async () => {
           try {
             const r = await fetch('https://api.ipify.org?format=json');
@@ -306,48 +363,50 @@ export class LinkedInAcceptInvitationsTool extends ToolBubble {
           } catch { return null; }
         })()
       `));
+            }
+            catch {
+                return null;
+            }
         }
-        catch {
-            return null;
-        }
-    }
-    async performAction() {
-        try {
-            await this.stepStartBrowserSession();
-            await this.stepNavigateToInvitationManager();
-            const pageReady = await this.stepWaitForInvitationsPage();
-            if (!pageReady)
-                console.log('[AcceptInvitations] Page slow to load, continuing');
-            const { accepted, skipped, availableCount } = await this.stepAcceptTopInvitations();
-            const count = this.params.count ?? 5;
-            // Success if we accepted all requested, OR if fewer were available than requested
-            const allAvailableAccepted = availableCount < count
-                ? accepted.length >= availableCount
-                : accepted.length >= count;
-            return {
-                operation: 'accept_invitations',
-                success: allAvailableAccepted,
-                accepted,
-                accepted_count: accepted.length,
-                skipped_count: skipped,
-                message: allAvailableAccepted
-                    ? `Accepted ${accepted.length} invitation(s)${availableCount < count ? ` (only ${availableCount} available)` : ''}`
-                    : `Accepted ${accepted.length}/${count} invitation(s), ${skipped} failed`,
-                error: allAvailableAccepted
-                    ? ''
-                    : `Failed to accept ${skipped} invitation(s)`,
-            };
-        }
-        catch (error) {
-            return {
-                operation: 'accept_invitations',
-                success: false,
-                error: error instanceof Error ? error.message : 'Unknown error',
-            };
-        }
-        finally {
-            await this.stepEndBrowserSession();
+        async performAction() {
+            try {
+                await this.stepStartBrowserSession();
+                await this.stepNavigateToInvitationManager();
+                const pageReady = await this.stepWaitForInvitationsPage();
+                if (!pageReady)
+                    console.log('[AcceptInvitations] Page slow to load, continuing');
+                const { accepted, skipped, availableCount } = await this.stepAcceptTopInvitations();
+                const count = this.params.count ?? 5;
+                // Success if we accepted all requested, OR if fewer were available than requested
+                const allAvailableAccepted = availableCount < count
+                    ? accepted.length >= availableCount
+                    : accepted.length >= count;
+                return {
+                    operation: 'accept_invitations',
+                    success: allAvailableAccepted,
+                    accepted,
+                    accepted_count: accepted.length,
+                    skipped_count: skipped,
+                    message: allAvailableAccepted
+                        ? `Accepted ${accepted.length} invitation(s)${availableCount < count ? ` (only ${availableCount} available)` : ''}`
+                        : `Accepted ${accepted.length}/${count} invitation(s), ${skipped} failed`,
+                    error: allAvailableAccepted
+                        ? ''
+                        : `Failed to accept ${skipped} invitation(s)`,
+                };
+            }
+            catch (error) {
+                return {
+                    operation: 'accept_invitations',
+                    success: false,
+                    error: error instanceof Error ? error.message : 'Unknown error',
+                };
+            }
+            finally {
+                await this.stepEndBrowserSession();
+            }
         }
-    }
-}
+    };
+})();
+export { LinkedInAcceptInvitationsTool };
 //# sourceMappingURL=tool.js.map