// Get all tabs across all windows
const tabs = await get_all_tabs()
console.log(`Found ${tabs.length} tabs`)

// Get current active tab information
const currentTab = await get_current_tab()

// Switch to specific tab
await switch_to_tab({ tabId: 123 })

// Create new tab with automatic URL format handling
const newTab = await create_new_tab({ url: "example.com" })

// Get detailed information about specific tab
const tabInfo = await get_tab_info({ tabId: 123 })

// Duplicate existing tab
await duplicate_tab({ tabId: 123 })

// Close specific tab
await close_tab({ tabId: 123 })

// Use AI to automatically analyze and group tabs
const result = await organize_tabs()

// Remove all tab groups in current window
await ungroup_tabs()

// Get page metadata
const metadata = await get_page_metadata()
// Returns: title, description, keywords, author, OG images, etc.

// Scroll to specific element
await scroll_to_element({ selector: ".target-element" })

// Highlight page elements
await highlight_element({ selector: ".important" })

// Highlight text within page
await highlight_text_inline({
  selector: "p",
  searchText: "important content"
})

// Create accessibility-based page snapshot
const snapshot = await take_snapshot()
// Returns: element list with unique IDs

// Click element by unique ID
await click({ uid: 'snapshot_1_5' })

// Intelligently fill form elements
await fill_element_by_uid({
  uid: 'snapshot_1_7',
  value: 'user input content'
})

// Fill multiple form elements at once
await fill_form({
  elements: [
    { uid: 'field1', value: 'value1' },
    { uid: 'field2', value: 'value2' }
  ]
})

// Hover over specific element
await hover_element_by_uid({ uid: 'snapshot_1_8' })

// Download text as Markdown file
await download_text_as_markdown({
  text: "# Title\nContent",
  filename: "document.md"
})

// Download image file
await download_image({
  imageData: "base64-data",
  filename: "image.png"
})

// Download images from chat
await download_chat_images({
  messages: chatMessages,
  folderPrefix: "chat-images"
})

// Download all images from current chat
await download_current_chat_images({
  folderPrefix: "current-chat"
})

// Capture current tab screenshot
const screenshot = await capture_screenshot()
// Returns: base64 encoded image data

// Capture specific tab screenshot
const screenshot = await capture_tab_screenshot({ tabId: 123 })

// Save screenshot directly to clipboard
await capture_screenshot_to_clipboard()

// Typical workflow combination
async function researchWorkflow(topic) {
  // 1. Create new tab
  const tab = await create_new_tab({ url: `https://google.com/search?q=${topic}` })

  // 2. Wait for page load
  await waitForStableDom()

  // 3. Extract page content
  const content = await get_page_metadata()

  // 4. Get related links
  const links = await getPageLinks()

  // 5. Save as Markdown
  await download_text_as_markdown({
    text: content.text,
    filename: `research-${topic}`
  })

  return { content, links }
}

async function robustOperation() {
  try {
    // Wait for DOM stability
    await waitForStableDom()

    // Execute operation
    const result = await click({ uid: 'element_uid' })

    // Verify result
    await waitForEventsAfterAction(() => {
      // Wait for operation completion
    })

    return result
  } catch (error) {
    console.error('Operation failed:', error)
    // Retry or fallback strategy
  }
}

// Batch operations to reduce API calls
async function batchTabOperations() {
  const tabs = await get_all_tabs()

  // Batch process instead of individual processing
  const operations = tabs.map(tab =>
    get_tab_info({ tabId: tab.id })
  )

  const results = await Promise.all(operations)
  return results
}

User: "Help me organize work-related tabs"
AI automatically executes:
1. get_all_tabs() - Get all tabs
2. organize_tabs() - AI analysis and grouping
3. create_tab_group() - Create related groups

// Multi-tab data collection
async function collectDataFromMultipleTabs() {
  const tabs = await get_all_tabs()
  const results = []

  for (const tab of tabs) {
    await switch_to_tab({ tabId: tab.id })
    const content = await get_page_metadata()
    results.push({ tab: tab.title, content })
  }

  return results
}

// Combine multiple tools for deep analysis
async function analyzePageContent() {
  const [metadata, snapshot] = await Promise.all([
    get_page_metadata(),
    take_snapshot()
  ])

  return {
    summary: {
      title: metadata.title,
      elementCount: snapshot.elements.length
    },
    content: { metadata, snapshot }
  }
}

// Complete research workflow
async function researchWorkflow(query) {
  // 1. Search
  await create_new_tab({ url: `https://google.com/search?q=${query}` })
  await waitForStableDom()

  // 2. Collect information
  const content = await get_page_metadata()

  // 3. Save results
  const markdown = `# ${query} Research Results\n\n${content.description}`

  await download_text_as_markdown({
    text: markdown,
    filename: `research-${query}`
  })

  return { content }
}