AI Agent Execute

import { test, expect } from '@stablyai/playwright-test';

import { test, expect } from '@stablyai/playwright-test';

test('apply for a remote position', async ({ agent, page }) => {
  // Navigate to the starting page
  await page.goto('https://company.com/careers');

  // Execute a multi-step task that might span multiple tabs
  await agent.act(
    'Find remote senior software engineer roles, filter by full-time, and submit an application',
    { page, maxCycles: 25 }
  );

  console.log('Application submitted successfully');
});

await agent.act(
  prompt: string,
  options: {
    page: Page;
    maxCycles?: number;
    model?: string;
  }
): Promise<{ success: boolean }>

await agent.act(
  'Complete the onboarding form: name is "Alex Chen", company is "Acme Corp", team size 50-100',
  { page, maxCycles: 15 }
);

await agent.act(
  'Find studio headphones under $500, sort by highest rating, and add the top result to cart',
  { page, maxCycles: 20 }
);

await page.goto('https://docs.example.com');

await agent.act(
  'Navigate to the API reference section and find the authentication endpoint documentation',
  { page, maxCycles: 10 }
);

await agent.act(
  'Subscribe to the newsletter if there is a popup, otherwise proceed to checkout',
  { page, maxCycles: 12 }
);

import { test, expect } from '@stablyai/playwright-test';

test.describe('E-commerce checkout flow', () => {
  test.beforeEach(async ({ agent, page }) => {
    // Navigate to the starting page
    await page.goto('https://shop.example.com');
    
    // Set up test data: add products to cart
    await agent.act(
      'Search for "wireless mouse", add the first result to cart, then search for "USB cable" and add it to cart',
      { page, maxCycles: 20 }
    );
  });

  test.afterEach(async ({ agent, page }) => {
    // Clean up: clear cart and sign out
    await agent.act(
      'Navigate to cart, remove all items, then sign out',
      { page, maxCycles: 15 }
    );
  });

  test('apply discount code', async ({ agent, page }) => {
    // Test assumes cart is already populated from beforeEach
    await agent.act(
      'Go to checkout, enter discount code "SAVE20", and verify discount is applied',
      { page, maxCycles: 10 }
    );
    
    await expect(page.locator('.discount-applied')).toBeVisible();
  });

  test('update shipping address', async ({ agent, page }) => {
    await agent.act(
      'Go to checkout, change shipping address to 123 Main St, New York, NY 10001',
      { page, maxCycles: 15 }
    );
    
    await expect(page.locator('.shipping-address')).toContainText('123 Main St');
  });
});

// Set maxCycles to prevent runaway execution
await agent.act(
  'Search for JavaScript frameworks and bookmark the top 3',
  { page, maxCycles: 15 } // Agent stops after 15 cycles if task isn't complete
);

await agent.act(
  'Find and compare pricing plans across 3 SaaS products, then fill out a trial signup for the cheapest',
  { page, maxCycles: 40 } // Higher limit for complex workflows
);

await agent.act(
  `Complete the medical insurance form with provided information. 
  Use conservative estimates when exact values are unavailable.
  Skip optional fields unless explicitly mentioned.`,
  { page }
);

test('research and compare products across vendors', async ({ agent, page }) => {
  await page.goto('https://search.example.com');

  await agent.act(
    `Search for "wireless keyboards", 
    visit the product pages of the top 3 results,
    and perform the checkout flow for the highest rated product`,
    { page, maxCycles: 30 }
  );
});

// From context
test('manual agent from context', async ({ context, page }) => {
  const agent = context.newAgent();
  await agent.act('Complete the form', { page });
});

// From browser
test('manual agent from browser', async ({ browser, page }) => {
  const agent = browser.newAgent();
  await agent.act('Complete the form', { page });
});

// ✅ Good: Start on the relevant page
await page.goto('https://github.com/browserbase/stagehand');
await agent.act(
  'Get the latest merged PR on this repo',
  { page, maxCycles: 10 }
);

// ❌ Avoid: Starting from an unrelated page
await page.goto('https://github.com');
await agent.act(
  'Get the latest PR on browserbase/stagehand',
  { page, maxCycles: 10 }
); // Agent wastes cycles navigating

// ✅ Specific instruction
await agent.act(
  'Find Italian restaurants in Brooklyn open after 10pm with outdoor seating, sorted by rating',
  { page, maxCycles: 20 }
);

// ❌ Vague instruction
await agent.act(
  'Find restaurants',
  { page, maxCycles: 20 }
); // Too ambiguous

// First task: search and filter
await agent.act(
  'Search for MacBook Pro and filter by 16-inch models under $2500',
  { page, maxCycles: 15 }
);

// Second task: checkout
await agent.act(
  'Add the top result to cart and proceed to checkout',
  { page, maxCycles: 15 }
);

await agent.act(
  'Subscribe to the Pro plan',
  { page, maxCycles: 20 }
);

// Verify the outcome
await expect(page.locator('.success-message')).toBeVisible();
await expect(page).toHaveURL(/checkout\/success/);

// Increase maxCycles for complex tasks
await agent.act(
  'Complete the 5-page registration form with all required fields',
  { page, maxCycles: 40 } // Increased limit
);

// Or break into smaller tasks
await agent.act(
  'Complete pages 1-2 of the registration form',
  { page, maxCycles: 15 }
);

await agent.act(
  'Complete pages 3-5 of the registration form',
  { page, maxCycles: 20 }
);

// Provide clearer context in the prompt
await agent.act(
  `Apply to the first full-time senior software engineer role listed.
  You are searching for professional software engineering jobs.
  Ignore internships, contract roles, and non-engineering positions.`,
  { page, maxCycles: 20 }
);

try {
  await agent.act(
    'Complete checkout',
    { page, maxCycles: 15 }
  );
} catch (error) {
  console.error('Agent execution failed:', error.message);
  // Example: "Could not find payment method selector after 12 cycles"
}