1. 项目概述：为什么AI Agent需要浏览器边界？

最近在折腾AI Agent项目，特别是那些需要自动化操作网页的，比如数据抓取、表单填写、流程测试。Puppeteer几乎是Node.js生态里的首选工具，它让程序像真人一样控制Chrome或Chromium浏览器，点击、输入、滚动，无所不能。但问题也恰恰出在这里——当你把浏览器这个“庞然大物”交给一个自主决策的AI Agent时，失控的风险就急剧放大了。想象一下，你的Agent本意是去电商网站查询商品价格，结果它可能因为页面弹窗而误点广告，甚至开始自动下载不明文件，或者陷入某个无限循环的页面跳转中。这不仅仅是浪费资源，更可能引发安全、法律和稳定性的一系列问题。

所以，“给AI Agent使用Puppeteer之前，先定义浏览器边界”这个标题，直指了AI Agent开发中一个至关重要却常被忽视的环节： 安全沙箱与行为约束 。这不仅仅是技术配置，更是一种设计哲学。它意味着我们需要在赋予Agent强大能力的同时，为它划定清晰的“活动范围”，告诉它什么能做，什么绝对不能碰，以及如何优雅地处理意外。这就像教一个孩子使用厨房，不是禁止他进入，而是明确告诉他炉灶很烫不能摸，刀具要小心使用，做完饭要关火。对于AI Agent而言，浏览器就是它的“厨房”，而Puppeteer的配置和我们的封装代码，就是那套“安全操作规程”。

这篇文章，就是基于我多次在真实项目中“踩坑”后，总结出的一套为AI Agent定义Puppeteer浏览器边界的实战方案。无论你是刚开始接触AI Agent与浏览器自动化的新手，还是正在为Agent的稳定性头疼的资深开发者，这些关于资源限制、导航策略、异常处理和监控的细节，都能帮你构建一个更可靠、更安全的自动化智能体。

2. 核心边界定义与设计思路拆解

在动手写一行Puppeteer代码之前，我们必须想清楚：我们希望AI Agent在浏览器环境中扮演什么角色？一个无所不能的管理员，还是一个权限受限的特定任务执行者？显然，为了安全和稳定，后者才是更合理的选择。定义边界，就是从以下几个维度给Agent“戴上镣铐跳舞”。

2.1 资源消耗边界：防止Agent“吃光”你的内存和CPU

浏览器，尤其是Chrome，是著名的资源消耗大户。一个未经约束的Puppeteer实例，动辄占用数百MB内存，如果AI Agent并发启动多个实例，或者某个实例因故未能正常关闭，很容易导致服务器内存耗尽而崩溃。

核心设计思路 是：为每个Puppeteer浏览器实例设定严格的资源配额和生命周期。

  1. 内存与CPU限制 ：虽然Puppeteer本身不直接提供硬性内存上限设置，但我们可以通过启动参数和外部监控来约束。例如，使用 --max-old-space-size 启动Node.js进程来限制V8内存，但这更多是约束Node端。对于浏览器进程，更实际的做法是在Docker容器或Kubernetes Pod中部署Agent，利用cgroups限制其整体的CPU和内存使用。这是一种基础设施层的边界。
  2. 实例池化与超时销毁 ：绝不建议为每个任务都启动/关闭一个浏览器。应该建立一个浏览器实例池（Browser Pool）。池中的每个实例都有最大空闲时间（例如10分钟），超时后自动关闭，释放资源。同时，为每个页面（Page）设置操作超时（如 page.setDefaultTimeout(30000) ），防止某个页面操作（如等待某个元素）永久阻塞。
  3. 并发数限制 ：限制Agent同时可操作的浏览器页面（Page）数量。一个浏览器实例虽然可以打开多个标签页，但过多会严重影响性能。通常，一个实例同时处理3-5个页面是比较稳健的。

实操心得 ：我曾遇到一个Agent在爬取数据时，因为目标网站页面结构复杂、资源众多，单个页面内存就涨到了800MB。解决方案是，在启动浏览器时传递 --disable-dev-shm-usage 和 --disable-gpu 参数（在无头服务器环境下很有用），并强制在每处理完N个页面后，重启浏览器实例，以清空累积的内存碎片。

2.2 导航与域名边界：把Agent“锁”在目标网站内

AI Agent的逻辑有时并不完全可靠。一个旨在处理站内搜索的Agent，可能会因为点击了一个站外链接，而跑到一个完全无关的、甚至是不安全的网站上去。我们必须限制它的“活动范围”。

核心设计思路 是：实施白名单机制，并拦截所有非预期的导航请求。

  1. 请求拦截与过滤 ：这是最重要的防线。通过 page.setRequestInterception(true) 开启请求拦截，然后在 request 事件监听器中，检查每个请求的URL。 
    await page.setRequestInterception(true);
page.on('request', (request) => {
  const url = request.url();
  // 只允许访问特定域名下的资源，阻止其他所有请求（如图片、脚本、XHR）
  if (!url.startsWith('https://target-website.com') && !url.startsWith('https://cdn.target-website.com')) {
    request.abort(); // 或 request.continue() 根据策略决定
  } else {
    request.continue();
  }
});
    这不仅能防止导航出界，还能大幅提升页面加载速度，因为阻止了广告、追踪器等无关资源的加载。
  2. 导航超时与重试策略 ：为 page.goto() 设置合理的超时时间（如30秒），并准备重试逻辑。网络波动或目标网站暂时不可用是常态，Agent不应因此而死掉。 
    const maxRetries = 3;
for (let i = 0; i < maxRetries; i++) {
  try {
    await page.goto('https://target-website.com', { waitUntil: 'networkidle2', timeout: 30000 });
    break; // 成功则跳出循环
  } catch (error) {
    if (i === maxRetries - 1) throw error; // 重试次数用尽，抛出错误
    console.log(`导航失败，第${i + 1}次重试...`);
    await new Promise(resolve => setTimeout(resolve, 2000)); // 等待2秒后重试
  }
}

2.3 操作行为边界：禁止危险动作，模拟人类节奏

即使是在允许的网站内，我们也需要限制Agent的具体操作，避免触发网站的反爬机制，或做出破坏性行为。

核心设计思路 是：封装一个安全的“动作执行器”，代替直接使用Puppeteer的原生API。

  1. 禁止下载与上传 ：在浏览器启动参数中，禁用下载提示并指定下载目录为空或只读目录，或者直接拦截所有可能导致下载的请求（如 application/octet-stream ）。对于文件上传，除非任务明确需要，否则应避免提供相关能力，或严格限制可上传的文件类型和路径。 
    const browser = await puppeteer.launch({
  args: [
    '--disable-features=DownloadBubble',
    '--disable-features=DownloadNotification',
    '--default-downloads-directory=/dev/null' // Linux系统下，指向空设备
  ]
});
  2. 模拟人类操作节奏 ：瞬间完成点击、输入等操作极易被识别为机器人。在执行任何动作前，加入随机延迟。可以封装一个 safeClick 或 safeType 函数。 
    async function safeClick(page, selector) {
  await page.waitForSelector(selector, { visible: true });
  // 移动鼠标到元素上，稍作停留再点击
  const element = await page.$(selector);
  const box = await element.boundingBox();
  await page.mouse.move(box.x + box.width / 2, box.y + box.height / 2);
  await page.waitForTimeout(500 + Math.random() * 1000); // 随机延迟0.5-1.5秒
  await element.click();
}
  3. 敏感操作确认 ：对于删除、提交订单、支付等关键操作，不应完全交由AI Agent自主决策。可以在架构上设计一个“人工确认”或“二次验证”环节，或者要求Agent在执行前必须通过一个非常高置信度的校验逻辑。

3. 基于Puppeteer的边界技术实现详解

理论说完了，我们来看看如何用代码具体实现这些边界。我将以一个“安全增强型Puppeteer启动器”为例，逐步拆解。

3.1 创建安全的浏览器启动器

这个启动器负责生成一个被严格约束的浏览器实例。它整合了资源限制、安全参数和行为模拟的基础配置。

const puppeteer = require('puppeteer');
const os = require('os');

class SecureBrowserLauncher {
  constructor(options = {}) {
    this.defaultArgs = [
      '--no-sandbox', // 在容器化环境中有时需要，但需评估安全风险
      '--disable-setuid-sandbox',
      '--disable-dev-shm-usage', // 解决共享内存问题，对Docker环境尤其重要
      '--disable-gpu', // 无头模式下禁用GPU
      '--disable-accelerated-2d-canvas',
      '--disable-web-security', // **慎用**：仅当需要跨域且环境绝对安全时使用
      '--lang=en-US,en', // 设置浏览器语言
      `--window-size=1920,1080`,
    ];
    this.allowedDomains = options.allowedDomains || []; // 允许访问的域名白名单
    this.userAgent = options.userAgent || 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 ...'; // 自定义UA
  }

  async launch() {
    // 计算合理的并发限制，例如根据CPU核心数
    const maxConcurrentPages = Math.max(1, Math.floor(os.cpus().length / 2));

    const browser = await puppeteer.launch({
      headless: 'new', // 使用新的Headless模式，更稳定
      args: this.defaultArgs,
      // 限制浏览器进程内存的间接方式：使用特定的Chrome版本或通过环境变量
      env: { ...process.env, NODE_OPTIONS: '--max-old-space-size=4096' }, // 限制Node进程内存为4GB
      defaultViewport: { width: 1920, height: 1080 },
      // 忽略HTTPS错误，对于内部测试环境可能有用，生产环境慎用
      ignoreHTTPSErrors: false,
    });

    // 监听浏览器实例的断开事件，便于日志和告警
    browser.on('disconnected', () => {
      console.warn('Browser instance was disconnected unexpectedly.');
      // 这里可以触发告警，或尝试重启逻辑
    });

    return {
      browser,
      maxConcurrentPages
    };
  }
}

注意事项 ： --no-sandbox 和 --disable-web-security 是高风险参数。仅在你知道其含义且运行环境是隔离的（如专用Docker容器）时才考虑使用。在生产环境中，应优先尝试在不使用这些参数的情况下运行。

3.2 实现带边界检查的页面包装器

获得浏览器实例后，我们需要创建一个“安全页面”。这个页面对象封装了原始的Puppeteer Page，但所有操作都经过了边界检查。

class SecurePage {
  constructor(basePage, allowedDomains, userAgent) {
    this.page = basePage;
    this.allowedDomains = allowedDomains;
    this.isRequestInterceptionEnabled = false;

    // 设置默认超时和用户代理
    this.page.setDefaultTimeout(30000);
    this.page.setUserAgent(userAgent);
  }

  async initialize() {
    // 1. 启用请求拦截
    await this.page.setRequestInterception(true);
    this.isRequestInterceptionEnabled = true;

    this.page.on('request', (request) => {
      const url = new URL(request.url());
      const isAllowed = this.allowedDomains.some(domain => url.hostname.endsWith(domain));

      if (!isAllowed) {
        console.log(`Blocked request to: ${request.url()}`);
        request.abort(); // 中止不允许的请求
      } else {
        // 对于允许的请求，可以根据资源类型进一步优化
        const resourceType = request.resourceType();
        // 可以阻止不必要的图片、字体等，加速加载
        if (['image', 'stylesheet', 'font', 'media'].includes(resourceType)) {
          request.continue();
        } else {
          request.continue();
        }
      }
    });

    // 2. 监听控制台和页面错误，便于调试和监控
    this.page.on('console', msg => console.log(`PAGE LOG: ${msg.type()}: ${msg.text()}`));
    this.page.on('pageerror', error => console.error(`PAGE ERROR: ${error}`));
    this.page.on('requestfailed', request => console.error(`REQUEST FAILED: ${request.url()} ${request.failure().errorText}`));

    // 3. 注入一个全局的“安全模式”标志，供页面内脚本检测（如果需要）
    await this.page.evaluateOnNewDocument(() => {
      window.__SECURE_AGENT_MODE__ = true;
    });

    return this;
  }

  async safeGoto(url, options = {}) {
    const targetUrl = new URL(url);
    if (!this.allowedDomains.some(domain => targetUrl.hostname.endsWith(domain))) {
      throw new Error(`Navigation to disallowed domain: ${targetUrl.hostname}`);
    }

    const gotoOptions = {
      waitUntil: 'networkidle2',
      timeout: 45000,
      ...options
    };

    try {
      const response = await this.page.goto(url, gotoOptions);
      if (!response.ok() && response.status() !== 304) { // 304是缓存，也算成功
        console.warn(`Page loaded with status: ${response.status()} for ${url}`);
      }
      return response;
    } catch (error) {
      console.error(`Failed to goto ${url}:`, error.message);
      // 这里可以加入截图逻辑，帮助调试
      await this.page.screenshot({ path: `error-${Date.now()}.png`, fullPage: true });
      throw error; // 重新抛出，由上层处理
    }
  }

  // 安全的查找并点击元素
  async safeClick(selector, options = {}) {
    const { delayBefore = 500, delayAfter = 300 } = options;
    try {
      await this.page.waitForSelector(selector, { visible: true, timeout: 10000 });
      const element = await this.page.$(selector);

      // 模拟人类鼠标移动
      const box = await element.boundingBox();
      await this.page.mouse.move(box.x + box.width / 2, box.y + box.height / 2, { steps: 10 }); // 分10步移动，更拟真
      await this.page.waitForTimeout(delayBefore + Math.random() * 1000);

      await element.click();
      await this.page.waitForTimeout(delayAfter + Math.random() * 500);
    } catch (error) {
      throw new Error(`Failed to safely click on selector "${selector}": ${error.message}`);
    }
  }

  // 安全的输入文本
  async safeType(selector, text, options = {}) {
    const { delayBetweenChars = 50, clearFirst = true } = options;
    await this.page.waitForSelector(selector, { visible: true, timeout: 10000 });
    if (clearFirst) {
      await this.page.click(selector, { clickCount: 3 }); // 三击全选
      await this.page.keyboard.press('Backspace');
    }
    for (const char of text) {
      await this.page.type(selector, char, { delay: delayBetweenChars + Math.random() * 50 });
    }
  }

  // 安全的评估脚本（限制执行时间）
  async safeEvaluate(pageFunction, ...args) {
    return await Promise.race([
      this.page.evaluate(pageFunction, ...args),
      new Promise((_, reject) => 
        setTimeout(() => reject(new Error('Page evaluation timeout')), 10000) // 10秒超时
      )
    ]);
  }
}

这个 SecurePage 类成为了AI Agent与真实浏览器交互的唯一中介。所有潜在危险的操作都必须通过它提供的方法，从而确保了边界策略的强制执行。

3.3 集成到AI Agent工作流中

现在，我们将这个安全浏览器系统集成到一个AI Agent的典型工作流中。假设我们有一个基于LLM（大语言模型）的Agent，它的任务是“去某电商网站搜索某个商品并返回前三名的价格”。

const { SecureBrowserLauncher, SecurePage } = require('./secure-puppeteer');
const LLMClient = require('./llm-client'); // 假设的LLM客户端

class ShoppingAgent {
  constructor() {
    this.browserLauncher = new SecureBrowserLauncher({
      allowedDomains: ['example-shop.com', 'cdn.example-shop.com']
    });
    this.llm = new LLMClient();
    this.browserContext = null;
    this.pagePool = [];
  }

  async init() {
    const { browser, maxConcurrentPages } = await this.browserLauncher.launch();
    this.browserContext = browser;
    this.maxConcurrentPages = maxConcurrentPages;
    console.log('Browser initialized with max pages:', maxConcurrentPages);
  }

  async createSecurePage() {
    if (!this.browserContext) throw new Error('Browser not initialized');
    const basePage = await this.browserContext.newPage();
    const securePage = new SecurePage(basePage, this.browserLauncher.allowedDomains, this.browserLauncher.userAgent);
    await securePage.initialize();
    this.pagePool.push(securePage);
    // 简单的池管理：如果超过限制，关闭最旧的页面
    if (this.pagePool.length > this.maxConcurrentPages) {
      const oldPage = this.pagePool.shift();
      await oldPage.page.close().catch(e => console.error('Error closing old page:', e));
    }
    return securePage;
  }

  async executeTask(productName) {
    let securePage;
    try {
      securePage = await this.createSecurePage();

      // 步骤1: 导航到网站首页
      await securePage.safeGoto('https://www.example-shop.com');

      // 步骤2: 让LLM分析页面，找到搜索框选择器（这里简化，实际可能用视觉或DOM分析）
      // 假设LLM返回了选择器 '#searchInput'
      const searchBoxSelector = '#searchInput';

      // 步骤3: 安全地输入商品名称并搜索
      await securePage.safeType(searchBoxSelector, productName);
      await securePage.safeClick('button[type="submit"]');

      // 步骤4: 等待结果加载，并提取数据
      await securePage.page.waitForSelector('.product-item', { timeout: 15000 });
      const productData = await securePage.safeEvaluate(() => {
        const items = Array.from(document.querySelectorAll('.product-item')).slice(0, 3);
        return items.map(item => ({
          name: item.querySelector('.product-name')?.innerText || 'N/A',
          price: item.querySelector('.price')?.innerText || 'N/A',
          link: item.querySelector('a')?.href || 'N/A'
        }));
      });

      return productData;

    } catch (error) {
      console.error('Agent task execution failed:', error);
      // 这里可以触发错误处理流程，比如通知人工、重试任务等
      throw error;
    } finally {
      // 任务结束，不是立即关闭页面，而是可能放回池中等待下次使用或超时清理
      // 这里演示直接关闭
      if (securePage) {
        const index = this.pagePool.indexOf(securePage);
        if (index > -1) this.pagePool.splice(index, 1);
        await securePage.page.close().catch(e => console.error('Error closing page in finally:', e));
      }
    }
  }

  async cleanup() {
    if (this.browserContext) {
      await this.browserContext.close();
      this.browserContext = null;
      this.pagePool = [];
    }
  }
}

// 使用示例
(async () => {
  const agent = new ShoppingAgent();
  try {
    await agent.init();
    const results = await agent.executeTask('wireless headphones');
    console.log('Search results:', results);
  } catch (error) {
    console.error('Agent run failed:', error);
  } finally {
    await agent.cleanup();
  }
})();

在这个工作流中，AI Agent（或驱动它的LLM）只负责高层的决策逻辑（例如，“下一步应该点击哪个按钮？”），而具体的、危险的操作（如导航、点击、输入）则全部通过我们定义的 SecurePage 安全接口来执行。这样，无论LLM的指令多么“疯狂”，其行为能力都被限制在了我们预设的安全边界之内。

4. 常见问题、监控与排查技巧实录

即使有了完善的边界定义，在实际运行中仍然会遇到各种问题。以下是我在实践中总结的一些典型场景和应对策略。

4.1 典型问题与解决方案速查表

问题现象 可能原因 排查步骤与解决方案
浏览器启动失败 1. 缺少Chrome/Chromium依赖。
2. 无头模式在特定环境下的兼容性问题。
3. 沙箱权限问题（常见于Docker容器）。		 1. 确保系统已安装Chromium或使用 puppeteer-core 并指定可执行路径。
2. 尝试使用 headless: 'new' 或 headless: false 测试。
3. 在Dockerfile中运行 apt-get install -y wget chromium ，并添加启动参数 --no-sandbox --disable-setuid-sandbox （评估安全风险）。
页面卡死或无响应 1. 页面JavaScript陷入死循环或内存泄漏。
2. 请求拦截逻辑有误，阻塞了关键资源。
3. 等待条件（ waitForSelector ）永远无法满足。		 1. 为页面操作设置超时（ page.setDefaultTimeout ）。
2. 检查请求拦截白名单，确保核心CSS/JS文件被放行。
3. 使用 Promise.race 为关键操作添加超时控制，超时后尝试刷新页面或重启浏览器标签页。
被网站识别为机器人 1. 浏览器指纹（User-Agent, WebGL等）过于标准。
2. 操作速度太快，毫无人类节奏。
3. 使用了明显的自动化特征（如 navigator.webdriver 为true）。		 1. 使用更真实的User-Agent，并考虑使用 puppeteer-extra-plugin-stealth 等插件。
2. 必须 在所有操作中加入随机延迟（如 safeClick 函数所示）。
3. 在 evaluateOnNewDocument 中注入脚本，覆盖或隐藏 webdriver 属性（注意法律和道德边界）。
内存使用持续增长 1. 页面缓存、DOM节点未释放。
2. 浏览器实例或页面未正确关闭。
3. 打开的页面数量过多。		 1. 定期（如每处理10个任务）关闭并重新创建浏览器实例。
2. 确保 在finally块或错误处理中关闭页面和浏览器。
3. 实施严格的页面池（Page Pool）管理，限制并发页面数。
导航被重定向到意外页面 1. 网站有登录墙或验证码。
2. 点击了广告或弹窗链接。
3. 请求拦截白名单配置过宽或过严。		 1. 在 safeGoto 后检查页面URL或标题，确认是否在预期页面。
2. 在点击前，用 page.$eval 检查元素属性（如 href ）是否在白名单内。
3. 仔细审查并收紧域名白名单，同时确保登录等必要跳转域名在其中。
截图或PDF生成空白 1. 页面未完全加载或渲染。
2. 在无头模式下，某些CSS或字体未加载。		 1. 在截图前使用 page.waitForSelector 等待关键元素出现，或使用 networkidle2 等待网络空闲。
2. 尝试设置 waitUntil: 'networkidle0' ，或增加额外的 page.waitForTimeout 。

4.2 监控与日志：为Agent装上“黑匣子”

一个不受监控的AI Agent是危险的。我们必须记录它的行为，以便在出错时进行复盘。

  1. 结构化日志 ：不要只用 console.log 。使用Winston、Pino等日志库，记录每次任务开始/结束、导航的URL、关键操作、发生的错误以及当时的截图。为每条日志附上唯一的任务ID或会话ID，方便追踪。 
    const logger = require('./logger'); // 你的日志模块
async function safeClickWithLog(page, selector, taskId) {
  logger.info({ taskId, selector }, 'Attempting to click element');
  try {
    // ... 点击逻辑 ...
    logger.info({ taskId, selector }, 'Click successful');
  } catch (error) {
    logger.error({ taskId, selector, error: error.message }, 'Click failed');
    await page.screenshot({ path: `/logs/${taskId}-click-error.png` });
    throw error;
  }
}
  2. 性能指标收集 ：监控每个页面的内存使用（可通过 page.metrics() 获取部分数据）、任务执行时间、浏览器实例的存活时间。当指标异常（如内存超过阈值、任务超时）时触发告警。
  3. 屏幕录像与DOM快照 ：对于复杂或关键的任务，可以考虑在无头模式下运行，但使用 page.screenshot({ path, fullPage: true }) 定期截图。更高级的做法是使用Puppeteer的 page.tracing 功能记录性能追踪数据，或者使用第三方库录制操作视频。在出错时，保存当前页面的HTML快照（ page.content() ），这对调试JavaScript渲染问题至关重要。

4.3 高级边界：动态策略与自适应行为

对于更复杂的场景，边界可以不是静态的，而是动态的。

  1. 基于内容的动态拦截 ：除了域名白名单，还可以拦截包含特定关键词的请求（如 /ads/ , tracking ），或者根据响应内容类型（MIME type）进行拦截。
  2. 操作频率限制 ：防止Agent在短时间内对同一元素进行重复操作（如快速连续点击提交按钮）。可以在 SecurePage 内部维护一个操作频率计数器。
  3. 异常行为检测与熔断 ：如果Agent在短时间内连续触发多次导航错误或被识别为机器人的情况，可以触发“熔断”机制，暂停该Agent的所有浏览器活动一段时间，并通知管理员检查。
  4. 环境感知配置 ：根据运行环境（开发、测试、生产）自动调整边界严格程度。例如，在开发环境可以放宽拦截以便调试，在生产环境则执行最严格的策略。

定义浏览器边界不是一个一劳永逸的配置，而是一个持续迭代的过程。你需要根据AI Agent的实际行为、目标网站的变化以及运行环境的反馈，不断调整和优化这些边界规则。最开始可能会觉得束手束脚，但正是这些约束，才能让你的AI Agent在复杂多变的网络环境中长期、稳定、安全地运行下去。

Logo
亚马逊云科技技术品牌专区

更多推荐

cover

一次 API 调用搞定时序预测：时序大模型 TimechoAI 使用与能力全解析

avatar 亚马逊云科技技术品牌专区
cover

智能软件工程AI4SE（十六）——需求工程工具Jira

avatar 亚马逊云科技技术品牌专区

AI Agent 面试题 353：A2A协议的服务发现和注册机制详解

A2A 协议 是 AI Agent 技术体系中的重要组成部分。简单来说，它涉及到 Agent 如何在 工具使用与函数调用 层面实现智能化的行为和决策。在实际应用中，A2A 协议 的核心目标是让 Agent 能够更加高效、准确地完成特定任务。这需要我们深入理解其底层原理和实现机制。从学术角度来看，A2A 协议 的研究可以追溯到人工智能的早期阶段。早在 1950 年代，Alan Turing 就提出了

avatar 亚马逊云科技技术品牌专区