# CronCreate

安排一个提示在将来某个时间入队。用于循环调度和一次性提醒。

使用用户本地时区的标准 5 字段 cron：分钟 小时 日 月 星期。"0 9 * * *" 表示当地时间上午 9 点——无需时区转换。

## 一次性任务（recurring: false）

对于"remind me at X"或"at <time>, do Y"的请求——触发一次后自动删除。将分钟/小时/日/月固定为具体值：
  "remind me at 2:30pm today to check the deploy" → cron: "30 14 <today_dom> <today_month> *", recurring: false
  "tomorrow morning, run the smoke test" → cron: "57 8 <tomorrow_dom> <tomorrow_month> *", recurring: false

## 循环任务（recurring: true，默认值）

对于"every N minutes" / "every hour" / "weekdays at 9am"的请求：
  "*/5 * * * *"（每 5 分钟），"0 * * * *"（每小时），"0 9 * * 1-5"（当地时间工作日上午 9 点）

## 在任务允许时避免 :00 和 :30 分钟标记

每个要求"9am"的用户都得到 `0 9`，每个要求"hourly"的用户都得到 `0 *`——这意味着来自全球各地的请求在同一瞬间到达 API。当用户的请求是近似值时，选择一个不是 0 或 30 的分钟：
  "every morning around 9" → "57 8 * * *" 或 "3 9 * * *"（不是 "0 9 * * *"）
  "hourly" → "7 * * * *"（不是 "0 * * * *"）
  "in an hour or so, remind me to..." → 选择你落在的任何分钟，不要取整

仅当用户明确说出确切时间并清楚表明意图时（"at 9:00 sharp", "at half past", 与会议协调），才使用分钟 0 或 30。如有疑问，提前或推迟几分钟——用户不会注意到，而整个系统集群会受益。

## 仅会话内有效

任务仅在此 Claude 会话中存在——不会写入磁盘，Claude 退出时任务消失。

## 不适合实时监视

CronCreate 按固定的挂钟时间间隔重新运行提示。要监视日志文件、进程或命令输出并在有变化时立即获知，请改用 Monitor 工具——Monitor 在事件发生时实时推送；cron 按计划轮询。

## 运行时行为

任务仅在 REPL 空闲时触发（不在查询进行中）。调度器在你选择的任何时间之上添加一个小的确定性抖动：循环任务最多延迟其周期的 10%（最大 15 分钟）；落在 :00 或 :30 的一次性任务最多提前 90 秒触发。选择非整分钟仍然是更大的杠杆。

循环任务在 7 天后自动过期——它们触发最后一次，然后被删除。这限制了会话的生命周期。在安排循环任务时告知用户 7 天的限制。

返回一个可传递给 CronDelete 的任务 ID。

```json
{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "additionalProperties": false,
  "properties": {
    "cron": {
      "description": "Standard 5-field cron expression in local time: \"M H DoM Mon DoW\" (e.g. \"*/5 * * * *\" = every 5 minutes, \"30 14 28 2 *\" = Feb 28 at 2:30pm local once).",
      "type": "string"
    },
    "durable": {
      "description": "true = persist to .claude/scheduled_tasks.json and survive restarts. false (default) = in-memory only, dies when this Claude session ends. Use true only when the user asks the task to survive across sessions.",
      "type": "boolean"
    },
    "prompt": {
      "description": "The prompt to enqueue at each fire time.",
      "type": "string"
    },
    "recurring": {
      "description": "true (default) = fire on every cron match until deleted or auto-expired after 7 days. false = fire once at the next match, then auto-delete. Use false for \"remind me at X\" one-shot requests with pinned minute/hour/dom/month.",
      "type": "boolean"
    }
  },
  "required": ["cron", "prompt"],
  "type": "object"
}
```

---

# CronDelete

取消之前使用 CronCreate 安排的 cron 任务。将其从内存会话存储中移除。

```json
{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "additionalProperties": false,
  "properties": {
    "id": {
      "description": "Job ID returned by CronCreate.",
      "type": "string"
    }
  },
  "required": ["id"],
  "type": "object"
}
```

---

# CronList

列出此会话中通过 CronCreate 安排的所有 cron 任务。

```json
{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "additionalProperties": false,
  "properties": {},
  "type": "object"
}
```

---

# EnterPlanMode

在你要开始一个非平凡的实施任务时主动使用此工具。在编写代码之前获得用户对你方法的批准可以防止浪费精力并确保一致。此工具将你转换到计划模式，在此模式下你可以探索代码库并设计实施方法以供用户批准。

## 何时使用此工具

**优先使用 EnterPlanMode** 进行实施任务，除非它们很简单。当以下任何条件适用时使用它：

1. **新功能实施**：添加有意义的新功能
   - 示例："添加注销按钮"——它应该放在哪里？点击时应该发生什么？
   - 示例："添加表单验证"——什么规则？什么错误消息？

2. **多种有效方法**：任务可以通过几种不同的方式解决
   - 示例："为 API 添加缓存"——可以使用 Redis、内存、基于文件等
   - 示例："提高性能"——许多优化策略可行

3. **代码修改**：影响现有行为或结构的更改
   - 示例："更新登录流程"——具体应该改变什么？
   - 示例："重构此组件"——目标架构是什么？

4. **架构决策**：任务需要在模式或技术之间做出选择
   - 示例："添加实时更新"——WebSockets vs SSE vs 轮询
   - 示例："实现状态管理"——Redux vs Context vs 自定义方案

5. **多文件更改**：任务可能涉及超过 2-3 个文件
   - 示例："重构认证系统"
   - 示例："添加带测试的新 API 端点"

6. **需求不明确**：在理解完整范围之前需要探索
   - 示例："让应用更快"——需要分析和识别瓶颈
   - 示例："修复结账中的错误"——需要调查根本原因

7. **用户偏好重要**：实施可以有多种合理的方式
   - 如果你会使用 AskUserQuestion 来澄清方法，请改用 EnterPlanMode
   - 计划模式让你先探索，然后呈现带有上下文的选项

## 何时不使用此工具

仅在以下简单任务时跳过 EnterPlanMode：
- 单行或少数几行的修复（拼写错误、明显错误、小调整）
- 添加具有明确需求的单个函数
- 用户给出非常具体、详细指令的任务
- 纯研究/探索任务（改用 Agent 工具配合 explore 代理）

## 计划模式下会发生什么

在计划模式下，你将：
1. 使用 `find`/Glob、`grep`/Grep 和 Read 彻底探索代码库
2. 理解现有模式和架构
3. 设计实施方法
4. 向用户展示你的计划以供批准
5. 如果需要澄清方法，使用 AskUserQuestion
6. 准备好实施时使用 ExitPlanMode 退出计划模式

## 示例

### GOOD - 使用 EnterPlanMode：

用户："为应用添加用户认证"
- 需要架构决策（会话 vs JWT、令牌存储位置、中间件结构）

用户："优化数据库查询"
- 多种方法可能，需要先进行性能分析，影响重大

用户："实现深色模式"
- 主题系统的架构决策，影响众多组件

用户："为用户资料添加删除按钮"
- 看似简单但涉及：放置位置、确认对话框、API 调用、错误处理、状态更新

用户："更新 API 中的错误处理"
- 影响多个文件，用户应批准方法

### BAD - 不要使用 EnterPlanMode：

用户："修复 README 中的拼写错误"
- 直接了当，无需规划

用户："添加 console.log 以调试此函数"
- 简单，显而易见的实现

用户："哪些文件处理路由？"
- 研究任务，不是实施规划

## 重要说明

- 此工具需要用户批准——他们必须同意进入计划模式
- 如果不确定是否使用，宁可选择规划——提前达成一致比返工更好
- 用户希望在对其代码库进行重大更改之前被咨询


---

```json
{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "additionalProperties": false,
  "properties": {},
  "type": "object"
}
```

---
# EnterWorktree

仅当明确指示在工作树中工作时才使用此工具——无论是用户直接指示，还是项目指令（CLAUDE.md / 记忆）指示。此工具创建一个隔离的 git 工作树并将当前会话切换到其中。

## 何时使用

- 用户明确提到"worktree"（例如"start a worktree", "work in a worktree", "create a worktree", "use a worktree"）
- CLAUDE.md 或记忆指令指示你为当前任务在工作树中工作

## 何时不使用

- 用户要求创建分支、切换分支或处理不同分支——使用 git 命令代替
- 用户要求修复错误或处理功能——使用正常的 git 工作流程，除非用户或项目指令明确要求工作树
- 除非用户或 CLAUDE.md / 记忆指令明确提到"worktree"，否则不要使用此工具

## 要求

- 必须在 git 仓库中，或者在 settings.json 中配置了 WorktreeCreate/WorktreeRemove 钩子
- 必须尚未处于工作树中

## 行为

- 在 git 仓库中：在 `.claude/worktrees/` 内创建一个新的 git 工作树，位于新分支上。基础引用由 `worktree.baseRef` 设置控制：`fresh`（默认）从 origin/<default-branch> 分支；`head` 从你当前的本地 HEAD 分支
- 在 git 仓库之外：委托给 WorktreeCreate/WorktreeRemove 钩子以实现 VCS 无关的隔离
- 将会话的工作目录切换到新工作树
- 使用 ExitWorktree 在会话中期离开工作树（保留或删除）。在会话退出时，如果仍在工作树中，将提示用户保留或删除它

## 进入现有工作树

传递 `path` 而不是 `name` 以将会话切换到一个已存在的工作树（例如，你刚刚用 `git worktree add` 创建的那个）。路径必须出现在当前仓库的 `git worktree list` 中——未注册为此仓库工作树的路径将被拒绝。ExitWorktree 不会移除通过这种方式进入的工作树；使用 `action: "keep"` 返回原始目录。

## 参数

- `name`（可选）：新工作树的名称。如果既未提供 `name` 也未提供 `path`，则生成随机名称。
- `path`（可选）：要切换到的当前仓库现有工作树的路径，而不是创建新工作树。与 `name` 互斥。


---

```json
{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "additionalProperties": false,
  "properties": {
    "name": {
      "description": "Optional name for a new worktree. Each \"/\"-separated segment may contain only letters, digits, dots, underscores, and dashes; max 64 chars total. A random name is generated if not provided. Mutually exclusive with `path`.",
      "type": "string"
    },
    "path": {
      "description": "Path to an existing worktree of the current repository to switch into instead of creating a new one. Must appear in `git worktree list` for the current repo. Mutually exclusive with `name`.",
      "type": "string"
    }
  },
  "type": "object"
}
```

---
# ExitPlanMode

当你在计划模式中，已完成向计划文件写入计划，并准备好等待用户批准时，使用此工具。

## 此工具的工作方式
- 你应该已经将计划写入计划模式系统消息中指定的计划文件
- 此工具不将计划内容作为参数——它将从你写入的文件中读取计划
- 此工具仅表示你已完成规划，准备好让用户审查和批准
- 用户审查时将看到你的计划文件内容

## 何时使用此工具
重要提示：仅当任务需要规划需要编写代码的实施的步骤时才使用此工具。对于你正在收集信息、搜索文件、阅读文件或通常试图了解代码库的研究任务——不要使用此工具。

## 使用此工具之前
确保你的计划完整且明确：
- 如果对需求或方法有未解决的问题，请先使用 AskUserQuestion（在早期阶段）
- 一旦计划最终确定，使用此工具请求批准
**重要：** 不要使用 AskUserQuestion 询问"这个计划可以吗？"或"我应该继续吗？"——这正是此工具的功能。ExitPlanMode 本质上是请求用户批准你的计划。

**重要：** 不要使用 AskUserQuestion 询问"这个计划可以吗？"或"我应该继续吗？"——这正是此工具的功能。ExitPlanMode 本质上是请求用户批准你的计划。

## 示例

1. 初始任务："Search for and understand the implementation of vim mode in the codebase"——不要使用退出计划模式工具，因为你没有在规划任务的实施步骤。
2. 初始任务："Help me implement yank mode for vim"——在完成规划任务的实施步骤后使用退出计划模式工具。
3. 初始任务："Add a new feature to handle user authentication"——如果不确定认证方法（OAuth、JWT 等），先使用 AskUserQuestion，然后在澄清方法后使用退出计划模式工具。

---

```json
{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "additionalProperties": {},
  "properties": {
    "allowedPrompts": {
      "description": "Prompt-based permissions needed to implement the plan. These describe categories of actions rather than specific commands.",
      "items": {
        "additionalProperties": false,
        "properties": {
          "prompt": {
            "description": "Semantic description of the action, e.g. \"run tests\", \"install dependencies\"",
            "type": "string"
          },
          "tool": {
            "description": "The tool this prompt applies to",
            "enum": ["Bash"],
            "type": "string"
          }
        },
        "required": ["tool", "prompt"],
        "type": "object"
      },
      "type": "array"
    }
  },
  "type": "object"
}
```


---
# ExitWorktree

退出由 EnterWorktree 创建的工作树会话并将会话返回到原始工作目录。

## 范围

此工具仅操作在此会话中由 EnterWorktree 创建的工作树。它不会涉及：
- 你手动使用 `git worktree add` 创建的工作树
- 先前会话中的工作树（即使是那时由 EnterWorktree 创建的）
- 如果从未调用 EnterWorktree，你所在的目录

如果在 EnterWorktree 会话之外调用，该工具是一个 **no-op**：它报告没有活动的工作树会话并且不采取任何操作。文件系统状态不变。

## 何时使用

- 用户明确要求"exit the worktree", "leave the worktree", "go back" 或以其他方式结束工作树会话
- 不要主动调用——仅在用户要求时

## 参数

- `action`（必需）：`"keep"` 或 `"remove"`
  - `"keep"`——保留工作树目录和分支在磁盘上。如果用户想要稍后回来继续工作，或者有需要保留的更改，请使用此项。
  - `"remove"`——删除工作树目录及其分支。工作完成或放弃时，使用此项进行干净退出。
- `discard_changes`（可选，默认为 false）：仅在 `action: "remove"` 时有意义。如果工作树有未提交的文件或不在原始分支上的提交，除非此项设置为 `true`，否则工具将拒绝移除。如果工具返回列出更改的错误，在重新调用 `discard_changes: true` 之前先与用户确认。

## 行为

- 将会话的工作目录恢复到 EnterWorktree 之前的位置
- 清除 CWD 相关的缓存（系统提示部分、内存文件、计划目录），使会话状态反映原始目录
- 如果 tmux 会话附加到工作树：在 `remove` 时终止，在 `keep` 时保持运行（返回其名称以便用户可以重新附加）
- 退出后，可以再次调用 EnterWorktree 以创建新的工作树

---

```json
{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "additionalProperties": false,
  "properties": {
    "action": {
      "description": "\"keep\" leaves the worktree and branch on disk; \"remove\" deletes both.",
      "enum": ["keep", "remove"],
      "type": "string"
    },
    "discard_changes": {
      "description": "Required true when action is \"remove\" and the worktree has uncommitted files or unmerged commits. The tool will refuse and list them otherwise.",
      "type": "boolean"
    }
  },
  "required": ["action"],
  "type": "object"
}
```


---
# Monitor

启动一个后台监视器，流式传输长时间运行脚本的事件。每行 stdout 就是一个事件——你可以继续工作，通知会出现在聊天中。事件按自己的计划到达，即使在你等待用户回答问题时有一个事件到达，它们也不是用户的回复。

根据你需要多少通知来选择：
- **One** ("tell me when the server is ready / the build finishes") → 使用带 `run_in_background` 的 **Bash**，以及一个在条件满足时退出的命令，例如 `until grep -q "Ready in" dev.log; do sleep 0.5; done`。当它退出时你会收到一个完成通知。
- **One per occurrence, indefinitely** ("tell me every time an ERROR line appears") → Monitor 配合无界命令（`tail -f`、`inotifywait -m`、`while true`）。
- **One per occurrence, until a known end** ("emit each CI step result, stop when the run completes") → Monitor 配合一个输出行然后退出的命令。

你的脚本的 stdout 就是事件流。每一行都变成一个通知。退出结束监视。

---

```json
{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "additionalProperties": false,
  "properties": {
    "command": {
      "description": "Shell command or script. Each stdout line is an event; exit ends the watch.",
      "type": "string"
    },
    "description": {
      "description": "Short human-readable description of what you are monitoring (shown in notifications).",
      "type": "string"
    },
    "persistent": {
      "default": false,
      "description": "Run for the lifetime of the session (no timeout). Use for session-length watches like PR monitoring or log tails. Stop with TaskStop.",
      "type": "boolean"
    },
    "timeout_ms": {
      "default": 300000,
      "description": "Kill the monitor after this deadline. Default 300000ms, max 3600000ms. Ignored when persistent is true.",
      "minimum": 1000,
      "type": "number"
    }
  },
  "required": ["description", "timeout_ms", "persistent", "command"],
  "type": "object"
}
```


---
  # Each matching log line is an event
  tail -f /var/log/app.log | grep --line-buffered "ERROR"

  # Each file change is an event
  inotifywait -m --format '%e %f' /watched/dir

  # Poll GitHub for new PR comments and emit one line per new comment
  last=$(date -u +%Y-%m-%dT%H:%M:%SZ)
  while true; do
    now=$(date -u +%Y-%m-%dT%H:%M:%SZ)
    gh api "repos/owner/repo/issues/123/comments?since=$last" --jq '.[] | "\(.user.login): \(.body)"'
    last=$now; sleep 30
  done

  # Node script that emits events as they arrive (e.g. WebSocket listener)
  node watch-for-events.js

  # Per-occurrence with a natural end: emit each CI check as it lands, exit when the run completes
  prev=""
  while true; do
    s=$(gh pr checks 123 --json name,bucket)
    cur=$(jq -r '.[] | select(.bucket!="pending") | "\(.name): \(.bucket)"' <<<"$s" | sort)
    comm -13 <(echo "$prev") <(echo "$cur")
    prev=$cur
    jq -e 'all(.bucket!="pending")' <<<"$s" >/dev/null && break
    sleep 30
  done

**不要为单个通知使用无界命令。** `tail -f`、`inotifywait -m` 和 `while true` 永远不会自行退出，所以即使事件已经触发，监视器也会保持武装直到超时。对于"tell me when X is ready"，使用带 `until` 循环的 Bash `run_in_background` 代替（一个通知，秒级结束）。注意 `tail -f log | grep -m 1 ...` 并*不*能解决这个问题：如果日志在匹配后变得安静，`tail` 永远不会收到 SIGPIPE，管道仍然挂起。

**脚本质量：**
- 在管道中始终使用 `grep --line-buffered`——没有它，管道缓冲会延迟事件数分钟。
- 在轮询循环中，处理瞬时故障（`curl ... || true`）——一次失败的请求不应终止监视器。
- 轮询间隔：远程 API 30 秒以上（速率限制），本地检查 0.5-1 秒。
- 编写具体的 `description`——它出现在每个通知中（"errors in deploy.log" 而不是 "watching logs"）。
- 只有 stdout 是事件流。Stderr 进入输出文件（可通过 Read 读取）但不会触发通知——对于你直接运行的命令（例如 `python train.py 2>&1 | grep --line-buffered ...`），使用 `2>&1` 合并 stderr 使其失败信息到达你的过滤器。（对现有日志的 `tail -f` 没有影响——该文件只包含其编写者重定向的内容。）

**覆盖范围——沉默不等于成功。** 在监视作业或进程的结果时，你的过滤器必须匹配每个终端状态，而不仅仅是正常路径。一个只 grep 成功标记的监视器会在崩溃循环、挂起进程或意外退出时保持沉默——而沉默看起来与"still running"一模一样。在激活之前，问自己：*if this process crashed right now, would my filter emit anything?* 如果不能，扩大范围。

  # Wrong — silent on crash, hang, or any non-success exit
  tail -f run.log | grep --line-buffered "elapsed_steps="

  # Right — one alternation covering progress + the failure signatures you'd act on
  tail -f run.log | grep -E --line-buffered "elapsed_steps=|Traceback|Error|FAILED|assert|Killed|OOM"

对于检查作业状态的轮询循环，在每个终端状态（`succeeded|failed|cancelled|timeout`）上输出，而不仅仅是成功。如果你不能自信地枚举所有失败特征，扩大 grep 交替而不是缩小它——多一些噪音总比错过崩溃循环好。

**输出量：** 每行 stdout 都是一条对话消息，所以过滤器应该有选择性——但"有选择性"意味着"the lines you'd act on"，而不是"only good news"。永远不要直接传递原始日志；使用 `grep --line-buffered`、`awk` 或一个精确输出你关心的成功和失败信号的包装器。产生过多事件的监视器会自动停止；如果发生这种情况，用更严格的过滤器重新启动。

200ms 内的 stdout 行会批量合并为一条通知，因此单个事件的多行输出会自然分组。

脚本在与 Bash 相同的 shell 环境中运行。退出结束监视（退出代码会被报告）。超时则被终止。设置 `persistent: true` 用于会话级监视（PR 监控、日志跟踪）——监视器运行直到你调用 TaskStop 或会话结束。使用 TaskStop 提前取消。

当一个事件落地且用户想要立即采取行动时——出现了错误，他们等待的状态发生了翻转——发送 PushNotification。并非每个事件都值得推送；那些会改变他们下一步行动的事件才值得。

# NotebookEdit

完全用新源代码替换 Jupyter 笔记本（.ipynb 文件）中特定单元格的内容。Jupyter 笔记本是交互式文档，结合了代码、文本和可视化，常用于数据分析和科学计算。notebook_path 参数必须是绝对路径，不能是相对路径。cell_number 是从 0 开始索引的。使用 edit_mode=insert 在 cell_number 指定的索引处添加新单元格。使用 edit_mode=delete 删除 cell_number 指定索引处的单元格。

---

```json
{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "additionalProperties": false,
  "properties": {
    "cell_id": {
      "description": "The ID of the cell to edit. When inserting a new cell, the new cell will be inserted after the cell with this ID, or at the beginning if not specified.",
      "type": "string"
    },
    "cell_type": {
      "description": "The type of the cell (code or markdown). If not specified, it defaults to the current cell type. If using edit_mode=insert, this is required.",
      "enum": ["code", "markdown"],
      "type": "string"
    },
    "edit_mode": {
      "description": "The type of edit to make (replace, insert, delete). Defaults to replace.",
      "enum": ["replace", "insert", "delete"],
      "type": "string"
    },
    "new_source": {
      "description": "The new source for the cell",
      "type": "string"
    },
    "notebook_path": {
      "description": "The absolute path to the Jupyter notebook file to edit (must be absolute, not relative)",
      "type": "string"
    }
  },
  "required": ["notebook_path", "new_source"],
  "type": "object"
}
```


---
# PushNotification

此工具在用户终端发送桌面通知。如果远程控制已连接，它还会推送到用户的手机。无论哪种方式，它都会将用户的注意力从他们正在做的事情中拉走——会议、其他任务、晚餐——到这个会话。这就是代价。好处是他们现在会知道一些他们想知道的事情：一个长时间的任务在他们离开时完成了，构建已就绪，你遇到了需要他们决定才能继续的事情。

因为不需要的通知会累积成烦扰，宁可少发。不要通知常规进度，或宣布你已经回答了他们几秒前问的问题且他们显然还在看，或一个快速任务完成时。在有可能他们已经走开并且有值得回来的事情时通知——或者当他们明确要求你通知他们时。

将消息控制在 200 个字符以内，一行，无 markdown。以他们会采取行动的内容开头——"build failed: 2 auth tests" 比 "task done" 告诉他们更多，也比状态转储更有用。

如果结果说推送未发送，这是预期的——无需操作。

---

```json
{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "additionalProperties": false,
  "properties": {
    "message": {
      "description": "The notification body. Keep it under 200 characters; mobile OSes truncate.",
      "minLength": 1,
      "type": "string"
    },
    "status": {
      "const": "proactive",
      "type": "string"
    }
  },
  "required": ["message", "status"],
  "type": "object"
}
```


---
# RemoteTrigger

调用 claude.ai 远程触发 API。使用此工具代替 curl——OAuth 令牌会在进程内自动添加，永远不会暴露。

操作：
- list: GET /v1/code/triggers
- get: GET /v1/code/triggers/{trigger_id}
- create: POST /v1/code/triggers（需要 body）
- update: POST /v1/code/triggers/{trigger_id}（需要 body，部分更新）
- run: POST /v1/code/triggers/{trigger_id}/run（可选 body）

响应是来自 API 的原始 JSON。对于 create/update，会附加一个摘要行，包含服务器解析的运行时间和例程的 claude.ai URL——将两者都转达给用户，以便他们确认时间正确并知道结果将出现在哪里。

---

```json
{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "additionalProperties": false,
  "properties": {
    "action": {
      "enum": ["list", "get", "create", "update", "run"],
      "type": "string"
    },
    "body": {
      "additionalProperties": {},
      "description": "Required for create and update; optional for run",
      "propertyNames": {"type": "string"},
      "type": "object"
    },
    "trigger_id": {
      "description": "Required for get, update, and run",
      "pattern": "^[\\w-]+$",
      "type": "string"
    }
  },
  "required": ["action"],
  "type": "object"
}
```


---
# ScheduleWakeup

安排在 /loop 动态模式下恢复工作的时间——用户调用了不带间隔的 /loop，要求你自行安排特定任务的迭代节奏。

不要安排短间隔唤醒来轮询你启动的后台工作——当工具跟踪的工作完成时，你会自动被重新调用，所以轮询是浪费的。相反，安排一个较长的后备时间（1200s 以上），这样如果工作挂起或从未通知，循环也能存活。例外是工具无法跟踪的外部工作（CI 运行、部署、远程队列）——这时，选择一个与实际状态变化速度相匹配的延迟。

每次轮次通过 `prompt` 传回相同的 /loop 提示，以便下次触发重复任务。对于自主 /loop（无用户提示），传递字面哨兵 `<<autonomous-loop-dynamic>>` 作为 `prompt`——运行时在触发时将其解析回自主循环指令。（还有一个类似的 `<<autonomous-loop>>` 哨兵用于基于 CronCreate 的自主循环；不要混淆两者——ScheduleWakeup 始终使用 `-dynamic` 变体。）省略调用以结束循环。

## 选择 delaySeconds

Anthropic 提示缓存的 TTL 为 5 分钟。睡眠超过 300 秒意味着下次唤醒时你的完整对话上下文未缓存——更慢也更昂贵。所以自然断点：

- **5 分钟以下（60s–270s）**：缓存保持温暖。适合主动轮询工具无法通知你的外部状态——CI 运行、部署、远程队列。
- **5 分钟到 1 小时（300s–3600s）**：承担缓存未命中的代价。适合没有更早检查的意义时——等待需要数分钟才能改变的事情，真正空闲时，或作为当其他信号是主要唤醒信号时的长后备心跳。

**不要选择 300s。** 这是两败俱伤：你承担了缓存未命中的代价却没有分摊它。如果你倾向于"wait 5 minutes"，要么降到 270s（留在缓存中），要么承诺 1200s 以上（一次缓存未命中换来更长的等待）。不要以整分钟为单位思考——以缓存窗口为单位思考。

对于没有特定信号要监视的空闲间隔，默认使用 **1200s–1800s**（20-30 分钟）。循环会回来看，你不会每小时白白消耗缓存 12 次，如果用户需要你更早，他们随时可以打断。

思考你实际上在等什么，而不仅仅是"how long should I sleep"。如果你在轮询一个大约需要 8 分钟的 CI 运行，睡 60s 会在它完成前消耗缓存 8 次——改为睡约 270s 两次。

运行时限制在 [60, 3600] 范围内，所以你不需要自己限制。

## reason 字段

一句话说明你选择了什么以及为什么。发送到遥测系统并显示给用户。"watching CI run" 比 "waiting" 好。用户通过阅读这个来理解你在做什么，而不必事先预测你的节奏——让它具体化。

---

```json
{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "additionalProperties": false,
  "properties": {
    "delaySeconds": {
      "description": "Seconds from now to wake up. Clamped to [60, 3600] by the runtime.",
      "type": "number"
    },
    "prompt": {
      "description": "The /loop input to fire on wake-up. Pass the same /loop input verbatim each turn so the next firing re-enters the skill and continues the loop. For autonomous /loop (no user prompt), pass the literal sentinel `<<autonomous-loop-dynamic>>` instead (the dynamic-pacing variant, not the CronCreate-mode `<<autonomous-loop>>`).",
      "type": "string"
    },
    "reason": {
      "description": "One short sentence explaining the chosen delay. Goes to telemetry and is shown to the user. Be specific.",
      "type": "string"
    }
  },
  "required": ["delaySeconds", "reason", "prompt"],
  "type": "object"
}
```


---
# SendMessage

向另一个代理发送消息。

```json
{"to": "researcher", "summary": "assign task 1", "message": "start on task #1"}
```

你的纯文本输出对其他代理不可见——要通信，你必须调用此工具。队友的消息会自动送达；你无需检查收件箱。通过名称引用活跃的队友；要恢复已完成的背景代理，使用其 spawn 结果中的 `agentId`（格式 `a...-...`）。在转发时，不要引用原文——它已经呈现给用户了。

## 协议响应（旧版）

如果你收到带有 `type: "shutdown_request"` 或 `type: "plan_approval_request"` 的 JSON 消息，用匹配的 `_response` 类型响应——回显 `request_id`，设置 `approve` 为 true/false：

```json
{"to": "team-lead", "message": {"type": "shutdown_response", "request_id": "...", "approve": true}}
{"to": "researcher", "message": {"type": "plan_approval_response", "request_id": "...", "approve": false, "feedback": "add error handling"}}
```

批准关闭会终止你的进程。拒绝计划会将队友送回修改。除非被要求，否则不要发起 `shutdown_request`。不要发送结构化的 JSON 状态消息——使用 TaskUpdate。

```json
{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "additionalProperties": false,
  "properties": {
    "message": {
      "anyOf": [
        {"description": "Plain text message content", "type": "string"},
        {
          "anyOf": [
            {
              "additionalProperties": false,
              "properties": {
                "reason": {"type": "string"},
                "type": {"const": "shutdown_request", "type": "string"}
              },
              "required": ["type"],
              "type": "object"
            },
            {
              "additionalProperties": false,
              "properties": {
                "approve": {"type": "boolean"},
                "reason": {"type": "string"},
                "request_id": {"type": "string"},
                "type": {"const": "shutdown_response", "type": "string"}
              },
              "required": ["type", "request_id", "approve"],
              "type": "object"
            },
            {
              "additionalProperties": false,
              "properties": {
                "approve": {"type": "boolean"},
                "feedback": {"type": "string"},
                "request_id": {"type": "string"},
                "type": {"const": "plan_approval_response", "type": "string"}
              },
              "required": ["type", "request_id", "approve"],
              "type": "object"
            }
          ]
        }
      ]
    },
    "summary": {
      "description": "A 5-10 word summary shown as a preview in the UI (required when message is a string)",
      "type": "string"
    },
    "to": {
      "description": "Recipient: teammate name",
      "type": "string"
    }
  },
  "required": ["to", "message"],
  "type": "object"
}
```

---

# TaskCreate

使用此工具为当前编码会话创建结构化的任务列表。这有助于你跟踪进度、组织复杂任务并向用户展示你的全面性。它还有助于用户了解任务的进度及其请求的整体进度。

## 何时使用此工具

在以下场景主动使用此工具：
- **复杂多步骤任务**——当任务需要 3 个或更多不同步骤或操作时
- **非平凡和复杂的任务**——需要仔细规划或多个操作并可能分配给队友的任务
- **计划模式**——使用计划模式时，创建任务列表以跟踪工作
- **用户明确要求待办列表**——当用户直接要求你使用待办列表时
- **用户提供多个任务**——当用户提供一系列要完成的事项时（编号或逗号分隔）
- **收到新指令后**——立即将用户需求捕获为任务
- **当你开始处理任务时**——在开始工作前将其标记为 in_progress
- **完成任务后**——将其标记为已完成，并添加实施过程中发现的任何新的后续任务

## 何时不使用此工具

跳过使用此工具的情况：
- 只有单个直接任务
- 任务很简单，跟踪它没有组织上的好处
- 任务可以在少于 3 个简单步骤内完成
- 任务纯粹是对话性或信息性的

注意，如果只有一个简单的任务要做，你不应该使用此工具。在这种情况下，你最好直接完成任务。

## 任务字段

- **subject**：祈使句形式的简要、可操作标题（例如"Fix authentication bug in login flow"）
- **description**：需要完成的工作
- **activeForm**（可选）：任务 in_progress 时旋转器中显示的现在进行时形式（例如"Fixing authentication bug"）。如果省略，旋转器显示 subject 代替。

所有任务创建时状态为 `pending`。

## 提示

- 创建具有清晰、具体主题描述结果的任务
- 创建任务后，如有需要，使用 TaskUpdate 设置依赖关系（blocks/blockedBy）
- 在描述中包含足够的细节，以便另一个代理能够理解并完成任务
- 新任务创建时状态为"pending"且没有所有者——使用带有 `owner` 参数的 TaskUpdate 来分配它们
- 先检查 TaskList 以避免创建重复任务

---

---

```json
{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "additionalProperties": false,
  "properties": {
    "activeForm": {
      "description": "Present continuous form shown in spinner when in_progress (e.g., \"Running tests\")",
      "type": "string"
    },
    "description": {
      "description": "What needs to be done",
      "type": "string"
    },
    "metadata": {
      "additionalProperties": {},
      "description": "Arbitrary metadata to attach to the task",
      "propertyNames": {"type": "string"},
      "type": "object"
    },
    "subject": {
      "description": "A brief title for the task",
      "type": "string"
    }
  },
  "required": ["subject", "description"],
  "type": "object"
}
```


---
# TaskGet

使用此工具通过任务 ID 从任务列表中检索任务。

## 何时使用此工具

- 当你在开始处理任务前需要完整的描述和背景信息时
- 为了了解任务依赖关系（它阻塞什么，什么阻塞它）
- 在分配任务后，获取完整的需求

## 输出

返回完整的任务详情：
- **subject**：任务标题
- **description**：详细的需求和背景
- **status**："pending"、"in_progress" 或 "completed"
- **blocks**：等待此任务完成的任务
- **blockedBy**：必须在此任务开始前完成的任务

## 提示

- 获取任务后，在开始工作前验证其 blockedBy 列表是否为空。
- 使用 TaskList 以摘要形式查看所有任务。

---

---

```json
{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "additionalProperties": false,
  "properties": {
    "taskId": {
      "description": "The ID of the task to retrieve",
      "type": "string"
    }
  },
  "required": ["taskId"],
  "type": "object"
}
```


---
# TaskList

使用此工具列出任务列表中的所有任务。

## 何时使用此工具

- 查看有哪些任务可以处理（状态："pending"，无所有者，未被阻塞）
- 检查项目的整体进度
- 查找被阻塞且需要解决依赖关系的任务
- 在将任务分配给队友之前，查看有哪些任务可用
- 完成任务后，检查新解锁的工作或领取下一个可用任务
- **优先按 ID 顺序处理任务**（ID 最小优先），因为较早的任务通常为后续任务设置上下文

## 输出

返回每个任务的摘要：
- **id**：任务标识符（与 TaskGet、TaskUpdate 一起使用）
- **subject**：任务的简要描述
- **status**："pending"、"in_progress" 或 "completed"
- **owner**：如果已分配则为代理 ID，如果可用则为空
- **blockedBy**：必须首先解决的任务 ID 列表（有 blockedBy 的任务在依赖关系解决前不能被认领）
使用 TaskGet 查看特定任务 ID 的完整详情，包括描述和评论。

## 队友工作流程

作为队友工作时：
1. 完成当前任务后，调用 TaskList 查找可用工作
2. 查找状态为"pending"、无所有者且 blockedBy 为空的任务
3. **优先按 ID 顺序处理任务**（ID 最小优先），因为较早的任务通常为后续任务设置上下文
4. 使用 TaskUpdate 认领可用任务（将 `owner` 设置为你的名称），或等待负责人分配
5. 如果被阻塞，专注于解除阻塞任务或通知团队负责人

```json
{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "additionalProperties": false,
  "properties": {},
  "type": "object"
}
```

---

# TaskOutput

已弃用：后台任务在工具结果中返回其输出文件路径，当任务完成时你会收到一个 <task-notification>，其中包含相同的路径。

- 对于 bash 任务：优先使用 Read 工具读取该输出文件路径——它包含 stdout/stderr。
- 对于 local_agent 任务：直接使用 Agent 工具结果。不要读取 .output 文件——它是完整子代理对话记录（JSONL）的符号链接，会溢出你的上下文窗口。
- 对于 remote_agent 任务：优先使用 Read 工具读取输出文件路径——它包含流式远程会话输出（与 bash 相同）。

- 从正在运行或已完成的任务（后台 shell、代理或远程会话）中检索输出
- 接受标识任务的 task_id 参数
- 返回任务输出以及状态信息
- 使用 block=true（默认）等待任务完成
- 使用 block=false 进行非阻塞检查当前状态
- 任务 ID 可以使用 /tasks 命令查找
- 适用于所有任务类型：后台 shell、异步代理和远程会话

---

---

```json
{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "additionalProperties": false,
  "properties": {
    "block": {
      "default": true,
      "description": "Whether to wait for completion",
      "type": "boolean"
    },
    "task_id": {
      "description": "The task ID to get output from",
      "type": "string"
    },
    "timeout": {
      "default": 30000,
      "description": "Max wait time in ms",
      "maximum": 600000,
      "minimum": 0,
      "type": "number"
    }
  },
  "required": ["task_id", "block", "timeout"],
  "type": "object"
}
```


---
# TaskStop

- 通过任务 ID 停止正在运行的后台任务
- 接受标识要停止的任务的 task_id 参数
- 返回成功或失败状态
- 当你需要终止长时间运行的任务时使用此工具

---

---

```json
{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "additionalProperties": false,
  "properties": {
    "shell_id": {
      "description": "Deprecated: use task_id instead",
      "type": "string"
    },
    "task_id": {
      "description": "The ID of the background task to stop",
      "type": "string"
    }
  },
  "type": "object"
}
```


---
# TaskUpdate

使用此工具更新任务列表中的任务。

## 何时使用此工具

**将任务标记为已解决：**
- 当你完成任务中描述的工作时
- 当任务不再需要或已被取代时
- 重要提示：完成后始终将你分配的任务标记为已解决
- 解决后，调用 TaskList 查找你的下一个任务

- 仅在完全完成任务时才将任务标记为已完成
- 如果遇到错误、阻塞或无法完成，保持任务为 in_progress
- 当被阻塞时，创建描述需要解决什么的新任务
- 如果出现以下情况，切勿将任务标记为已完成：
  - 测试失败
  - 实施不完整
  - 遇到未解决的错误
  - 找不到必要的文件或依赖

**删除任务：**
- 当任务不再相关或创建有误时
- 将状态设置为 `deleted` 永久移除任务

**更新任务详情：**
- 当需求变更或变得更清晰时
- 当建立任务之间的依赖关系时

## 你可以更新的字段

- **status**：任务状态（见下面的状态工作流程）
- **subject**：更改任务标题（祈使句形式，例如"Run tests"）
- **description**：更改任务描述
- **activeForm**：任务 in_progress 时旋转器中显示的现在进行时形式（例如"Running tests"）
- **owner**：更改任务所有者（代理名称）
- **metadata**：将元数据键合并到任务中（将键设置为 null 以删除它）
- **addBlocks**：标记在此任务完成前无法开始的任务
- **addBlockedBy**：标记必须在此任务开始前完成的任务

## 状态工作流程

状态推进：`pending` → `in_progress` → `completed`

使用 `deleted` 永久移除任务。

## 状态过时

在更新任务之前，请确保使用 `TaskGet` 读取任务的最新状态。

## 示例

开始工作时将任务标记为进行中：
```json
{"taskId": "1", "status": "in_progress"}
```

完成工作后将任务标记为已完成：
```json
{"taskId": "1", "status": "completed"}
```

删除任务：
```json
{"taskId": "1", "status": "deleted"}
```

通过设置所有者认领任务：
```json
{"taskId": "1", "owner": "my-name"}
```

设置任务依赖关系：
```json
{"taskId": "2", "addBlockedBy": ["1"]}
```

```json
{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "additionalProperties": false,
  "properties": {
    "activeForm": {
      "description": "Present continuous form shown in spinner when in_progress (e.g., \"Running tests\")",
      "type": "string"
    },
    "addBlockedBy": {
      "description": "Task IDs that block this task",
      "items": {"type": "string"},
      "type": "array"
    },
    "addBlocks": {
      "description": "Task IDs that this task blocks",
      "items": {"type": "string"},
      "type": "array"
    },
    "description": {
      "description": "New description for the task",
      "type": "string"
    },
    "metadata": {
      "additionalProperties": {},
      "description": "Metadata keys to merge into the task. Set a key to null to delete it.",
      "propertyNames": {"type": "string"},
      "type": "object"
    },
    "owner": {
      "description": "New owner for the task",
      "type": "string"
    },
    "status": {
      "anyOf": [
        {"enum": ["pending", "in_progress", "completed"], "type": "string"},
        {"const": "deleted", "type": "string"}
      ],
      "description": "New status for the task"
    },
    "subject": {
      "description": "New subject for the task",
      "type": "string"
    },
    "taskId": {
      "description": "The ID of the task to update",
      "type": "string"
    }
  },
  "required": ["taskId"],
  "type": "object"
}
```

---

# TeamCreate

## 何时使用

在以下情况主动使用此工具：
- 用户明确要求使用团队、群体或一组代理
- 用户提到希望代理协同工作、协调或协作
- 任务足够复杂，通过多个代理并行工作会受益（例如，构建包含前端和后端工作的全栈功能，重构代码库同时保持测试通过，实施包含研究、规划和编码阶段的多步骤项目）
当不确定任务是否需要团队时，优先启动团队。

## 为队友选择代理类型

在通过 Agent 工具启动队友时，根据队友任务所需的工具选择 `subagent_type`。每种代理类型具有不同的可用工具集——将代理与工作匹配：

- **只读代理**（例如 Explore、Plan）不能编辑或写入文件。只分配研究、搜索或规划任务给它们。永远不要分配实施工作。
- **全功能代理**（例如通用型）可以访问所有工具，包括文件编辑、写入和 bash。用于需要做出更改的任务。
- **自定义代理**在 `.claude/agents/` 中定义，可能有自己的工具限制。查看其描述以了解它们能做什么和不能做什么。

在选择队友的 `subagent_type` 之前，始终查看 Agent 工具提示中列出的代理类型描述及其可用工具。

创建一个新团队来协调多个代理在项目上工作。团队与任务列表一一对应（Team = TaskList）。

```
{
  "team_name": "my-project",
  "description": "Working on feature X"
}
```

这会创建：
- 团队文件位于 `~/.claude/teams/{team-name}/config.json`
- 对应的任务列表目录位于 `~/.claude/tasks/{team-name}/`

## 团队工作流程

1. **创建团队** 使用 TeamCreate——这会同时创建团队及其任务列表
2. **创建任务** 使用 Task 工具（TaskCreate、TaskList 等）——它们会自动使用团队的任务列表
3. **启动队友** 使用带有 `team_name` 和 `name` 参数的 Agent 工具来创建加入团队的队友
4. **分配任务** 使用带有 `owner` 参数的 TaskUpdate 将任务分配给空闲的队友
5. **队友处理分配的任务** 并通过 TaskUpdate 将它们标记为已完成
6. **队友在轮次之间进入空闲状态**——每轮之后，队友会自动进入空闲状态并发送通知。重要提示：对空闲的队友保持耐心！在其实际影响你的工作之前，不要评论他们的空闲状态。
7. **关闭你的团队**——任务完成后，通过 SendMessage 发送 `message: {type: "shutdown_request"}` 优雅地关闭你的队友。

## 任务所有权

任务使用带有 `owner` 参数的 TaskUpdate 分配。任何代理都可以通过 TaskUpdate 设置或更改任务所有权。

## 自动消息投递

**重要提示：** 来自队友的消息会自动投递给你。你无需手动检查收件箱。

当你启动队友时：
- 他们在完成任务或需要帮助时会向你发送消息
- 这些消息会自动出现为新的对话轮次（如用户消息）
- 如果你正忙（轮次中），消息会排队并在你的轮次结束时投递
- 当有消息等待时，UI 会显示一个带有发送者名称的简短通知

消息将自动投递。

在报告队友消息时，你不需要引用原始消息——它已经呈现给用户了。

## 队友空闲状态

队友每轮后都会进入空闲状态——这完全正常且符合预期。队友在向你发送消息后立即进入空闲状态并不意味着他们已完成或不可用。空闲仅仅意味着他们在等待输入。

- **空闲的队友可以接收消息。** 向空闲队友发送消息会唤醒他们，他们会正常处理。
- **空闲通知是自动的。** 每当队友的轮次结束时，系统会发送空闲通知。除非你想分配新工作或发送后续消息，否则你不需要对空闲通知做出反应。
- **不要将空闲视为错误。** 队友发送消息然后进入空闲状态是正常流程——他们发送了消息，现在正在等待响应。
- **队友间私信可见性。** 当队友向另一队友发送私信时，他们的空闲通知中会包含一个简短摘要。这让你在不查看完整消息内容的情况下了解队友间的协作。你不需要对这些摘要做出响应——它们仅提供信息。

## 发现团队成员

队友可以读取团队配置文件以发现其他团队成员：
- **团队配置位置**：`~/.claude/teams/{team-name}/config.json`

配置文件包含一个 `members` 数组，包含每个队友的：
- `name`：人类可读名称（**始终使用此名称**进行消息传递和任务分配）
- `agentId`：唯一标识符（仅供参考——不要用于通信）
- `agentType`：代理的角色/类型

**重要提示：** 始终通过他们的**名称**来引用队友（例如"team-lead"、"researcher"、"tester"）。名称用于：
- 发送消息时的 `to`
- 识别任务所有者

读取团队配置的示例：
```
使用 Read 工具读取 ~/.claude/teams/{team-name}/config.json
```

## 任务列表协调

团队共享一个所有队友都可以访问的任务列表，位于 `~/.claude/tasks/{team-name}/`。

队友应：
1. 定期检查 TaskList，**特别是在完成每个任务后**，以查找可用工作或查看新解锁的任务
2. 使用 TaskUpdate 认领未分配、未阻塞的任务（将 `owner` 设置为你的名称）。**优先按 ID 顺序处理任务**（ID 最小优先），因为较早的任务通常为后续任务设置上下文
3. 在发现额外工作时使用 `TaskCreate` 创建新任务
4. 完成后使用 `TaskUpdate` 将任务标记为已完成，然后检查 TaskList 寻找下一个工作
5. 通过读取任务列表状态与其他队友协调
6. 如果所有可用任务都被阻塞，通知团队负责人或帮助解决阻塞任务

**与团队沟通的重要说明：**
- 不要使用终端工具查看团队活动；始终向你的队友发送消息（记住，通过名称引用他们）。
- 如果你不使用 SendMessage 工具，你的团队听不到你的声音。如果要回复队友，始终向他们发送消息。
- 不要发送像 `{"type":"idle",...}` 或 `{"type":"task_completed",...}` 这样的结构化 JSON 状态消息。当需要给队友发消息时，用纯文本沟通即可。
- 使用 TaskUpdate 将任务标记为已完成。
- 如果你是团队中的代理，系统会在你停止时自动向团队负责人发送空闲通知。

```json
{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "additionalProperties": false,
  "properties": {
    "agent_type": {
      "description": "Type/role of the team lead (e.g., \"researcher\", \"test-runner\"). Used for team file and inter-agent coordination.",
      "type": "string"
    },
    "description": {
      "description": "Team description/purpose.",
      "type": "string"
    },
    "team_name": {
      "description": "Name for the new team to create.",
      "type": "string"
    }
  },
  "required": ["team_name"],
  "type": "object"
}
```

---

# TeamDelete

在团队工作完成后移除团队和任务目录。

此操作：
- 移除团队目录（`~/.claude/teams/{team-name}/`）
- 移除任务目录（`~/.claude/tasks/{team-name}/`）
- 清除当前会话中的团队上下文

**重要提示：** 如果团队仍有活跃成员，TeamDelete 将失败。先优雅地终止队友，然后在所有队友关闭后调用 TeamDelete。

在所有队友完成工作并且你想要清理团队资源时使用此工具。团队名称自动从当前会话的团队上下文中确定。

```json
{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "additionalProperties": false,
  "properties": {},
  "type": "object"
}
```

---

# WebFetch

获取 URL，将页面转换为 markdown，并使用一个小型快速模型针对其回答 `prompt`。

- 在需要认证/私有 URL 上失败——对此类 URL 使用经过认证的 MCP 工具或 `gh`。
- HTTP 会升级为 HTTPS。跨主机重定向会返回给你而不是跟随；用重定向 URL 再次调用。
- 响应按 URL 缓存 15 分钟。

```json
{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "additionalProperties": false,
  "properties": {
    "prompt": {
      "description": "The prompt to run on the fetched content",
      "type": "string"
    },
    "url": {
      "description": "The URL to fetch content from",
      "format": "uri",
      "type": "string"
    }
  },
  "required": ["url", "prompt"],
  "type": "object"
}
```

---

# WebSearch

搜索网络。返回带有标题和 URL 的结果块。仅限美国地区使用。

- 当前月份是 2026 年 5 月——在搜索最近信息时使用此信息。
- `allowed_domains` / `blocked_domains` 过滤结果。
- 根据结果回答后，以你使用的 URL 的"Sources:"列表结束，作为 markdown 链接。

```json
{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "additionalProperties": false,
  "properties": {
    "allowed_domains": {
      "description": "Only include search results from these domains",
      "items": {"type": "string"},
      "type": "array"
    },
    "blocked_domains": {
      "description": "Never include search results from these domains",
      "items": {"type": "string"},
      "type": "array"
    },
    "query": {
      "description": "The search query to use",
      "minLength": 2,
      "type": "string"
    }
  },
  "required": ["query"],
  "type": "object"
}
```

---

## mcp__claude-in-chrome__browser_batch

在**一次**往返中执行一系列浏览器工具调用。每个项是 {name, input}，其中 input 与你单独传递给该工具的内容完全相同。操作按**顺序**执行（非并行），并在第一个错误处停止。当你能够预测两个或更多步骤时，广泛使用此工具快速执行工作——例如导航、点击字段、输入、按回车、截图。每个工具自身的权限检查在每个项上运行——如果某个操作导航到没有权限的域名，下一项的检查会失败，批次停止。截图和其他图像与输出交错返回；你在本批次中写入的坐标指的是在此调用之前拍摄的截图。browser_batch 不能嵌套。

```json
{
  "properties": {
    "actions": {
      "description": "List of tool calls to execute sequentially. Example: [{\"name\":\"computer\",\"input\":{\"action\":\"left_click\",\"coordinate\":[100,200],\"tabId\":123}},{\"name\":\"computer\",\"input\":{\"action\":\"type\",\"text\":\"hello\",\"tabId\":123}},{\"name\":\"navigate\",\"input\":{\"url\":\"https://example.com\",\"tabId\":123}}]",
      "items": {
        "properties": {
          "input": {
            "description": "That tool's input — same shape you'd pass when calling it directly.",
            "type": "object"
          },
          "name": {
            "description": "Tool name (e.g. computer, navigate, find, tabs_create_mcp). browser_batch cannot be nested.",
            "type": "string"
          }
        },
        "required": ["name", "input"],
        "type": "object"
      },
      "minItems": 1,
      "type": "array"
    }
  },
  "required": ["actions"],
  "type": "object"
}
```

---

## mcp__claude-in-chrome__computer

使用鼠标和键盘与 Web 浏览器交互，并截取屏幕截图。如果你没有有效的标签页 ID，请先使用 tabs_context_mcp 获取可用标签页。
* 每当你打算点击图标等元素时，你应该先查看截图以确定元素的坐标，然后再移动光标。
* 如果你尝试点击程序或链接但加载失败，即使在等待之后，尝试调整点击位置，使光标尖端视觉上落在你要点击的元素上。
* 确保点击任何按钮、链接、图标等时，光标尖端位于元素的中心。除非被要求，不要在框的边缘点击。

```json
{
  "properties": {
    "action": {
      "description": "The action to perform:\n* `left_click`: Click the left mouse button at the specified coordinates.\n* `right_click`: Click the right mouse button at the specified coordinates to open context menus.\n* `double_click`: Double-click the left mouse button at the specified coordinates.\n* `triple_click`: Triple-click the left mouse button at the specified coordinates.\n* `type`: Type a string of text.\n* `screenshot`: Take a screenshot of the screen.\n* `wait`: Wait for a specified number of seconds.\n* `scroll`: Scroll up, down, left, or right at the specified coordinates.\n* `key`: Press a specific keyboard key.\n* `left_click_drag`: Drag from start_coordinate to coordinate.\n* `zoom`: Take a screenshot of a specific region for closer inspection.\n* `scroll_to`: Scroll an element into view using its element reference ID from read_page or find tools.\n* `hover`: Move the mouse cursor to the specified coordinates or element without clicking. Useful for revealing tooltips, dropdown menus, or triggering hover states.",
      "enum": ["left_click", "right_click", "type", "screenshot", "wait", "scroll", "key", "left_click_drag", "double_click", "triple_click", "zoom", "scroll_to", "hover"],
      "type": "string"
    },
    "coordinate": {
      "description": "(x, y): The x (pixels from the left edge) and y (pixels from the top edge) coordinates. Required for `left_click`, `right_click`, `double_click`, `triple_click`, and `scroll`. For `left_click_drag`, this is the end position.",
      "items": {"type": "number"},
      "maxItems": 2,
      "minItems": 2,
      "type": "array"
    },
    "duration": {
      "description": "The number of seconds to wait. Required for `wait`. Maximum 10 seconds.",
      "maximum": 10,
      "minimum": 0,
      "type": "number"
    },
    "modifiers": {
      "description": "Modifier keys for click actions. Supports: \"ctrl\", \"shift\", \"alt\", \"cmd\" (or \"meta\"), \"win\" (or \"windows\"). Can be combined with \"+\" (e.g., \"ctrl+shift\", \"cmd+alt\"). Optional.",
      "type": "string"
    },
    "ref": {
      "description": "Element reference ID from read_page or find tools (e.g., \"ref_1\", \"ref_2\"). Required for `scroll_to` action. Can be used as alternative to `coordinate` for click actions.",
      "type": "string"
    },
    "region": {
      "description": "(x0, y0, x1, y1): The rectangular region to capture for `zoom`. Coordinates define a rectangle from top-left (x0, y0) to bottom-right (x1, y1) in pixels from the viewport origin. Required for `zoom` action. Useful for inspecting small UI elements like icons, buttons, or text.",
      "items": {"type": "number"},
      "maxItems": 4,
      "minItems": 4,
      "type": "array"
    },
    "repeat": {
      "description": "Number of times to repeat the key sequence. Only applicable for `key` action. Must be a positive integer between 1 and 100. Default is 1. Useful for navigation tasks like pressing arrow keys multiple times.",
      "maximum": 100,
      "minimum": 1,
      "type": "number"
    },
    "save_to_disk": {
      "description": "For screenshot/zoom actions: save the image to disk so it can be attached to a message for the user. Returns the saved path in the tool result. Only set this when you intend to share the image — screenshots you're just looking at don't need saving.",
      "type": "boolean"
    },
    "scroll_amount": {
      "description": "The number of scroll wheel ticks. Optional for `scroll`, defaults to 3.",
      "maximum": 10,
      "minimum": 1,
      "type": "number"
    },
    "scroll_direction": {
      "description": "The direction to scroll. Required for `scroll`.",
      "enum": ["up", "down", "left", "right"],
      "type": "string"
    },
    "start_coordinate": {
      "description": "(x, y): The starting coordinates for `left_click_drag`.",
      "items": {"type": "number"},
      "maxItems": 2,
      "minItems": 2,
      "type": "array"
    },
    "tabId": {
      "description": "Tab ID to execute the action on. Must be a tab in the current group. Use tabs_context_mcp first if you don't have a valid tab ID.",
      "type": "number"
    },
    "text": {
      "description": "The text to type (for `type` action) or the key(s) to press (for `key` action). For `key` action: Provide space-separated keys (e.g., \"Backspace Backspace Delete\"). Supports keyboard shortcuts using the platform's modifier key (use \"cmd\" on Mac, \"ctrl\" on Windows/Linux, e.g., \"cmd+a\" or \"ctrl+a\" for select all).",
      "type": "string"
    }
  },
  "required": ["action", "tabId"],
  "type": "object"
}
```

---

## mcp__claude-in-chrome__file_upload

从本地文件系统上传一个或多个文件到页面上的文件输入元素。不要点击文件上传按钮或文件输入——点击会打开你无法看到或交互的原生文件选择器对话框。相反，使用 read_page 或 find 定位文件输入元素，然后使用此工具及其 ref 直接上传文件。路径必须是本地机器上的绝对文件路径。

```json
{
  "properties": {
    "paths": {
      "description": "The absolute paths to the files to upload. Can be a single file or multiple files.",
      "items": {"type": "string"},
      "type": "array"
    },
    "ref": {
      "description": "Element reference ID of the file input from read_page or find tools (e.g., \"ref_1\", \"ref_2\").",
      "type": "string"
    },
    "tabId": {
      "description": "Tab ID where the file input is located. Use tabs_context_mcp first if you don't have a valid tab ID.",
      "type": "number"
    }
  },
  "required": ["paths", "ref", "tabId"],
  "type": "object"
}
```

---

## mcp__claude-in-chrome__find

使用自然语言在页面上查找元素。可以按用途（例如"search bar"、"login button"）或按文本内容（例如"organic mango product"）搜索元素。返回最多 20 个匹配元素，附带有可与其他工具一起使用的引用。如果存在超过 20 个匹配，你会被通知使用更具体的查询。如果你没有有效的标签页 ID，请先使用 tabs_context_mcp 获取可用标签页。

```json
{
  "properties": {
    "query": {
      "description": "Natural language description of what to find (e.g., \"search bar\", \"add to cart button\", \"product title containing organic\")",
      "type": "string"
    },
    "tabId": {
      "description": "Tab ID to search in. Must be a tab in the current group. Use tabs_context_mcp first if you don't have a valid tab ID.",
      "type": "number"
    }
  },
  "required": ["query", "tabId"],
  "type": "object"
}
```

---

## mcp__claude-in-chrome__form_input

使用 read_page 工具的元素引用 ID 设置表单元素的值。如果你没有有效的标签页 ID，请先使用 tabs_context_mcp 获取可用标签页。

```json
{
  "properties": {
    "ref": {
      "description": "Element reference ID from the read_page tool (e.g., \"ref_1\", \"ref_2\")",
      "type": "string"
    },
    "tabId": {
      "description": "Tab ID to set form value in. Must be a tab in the current group. Use tabs_context_mcp first if you don't have a valid tab ID.",
      "type": "number"
    },
    "value": {
      "description": "The value to set. For checkboxes use boolean, for selects use option value or text, for other inputs use appropriate string/number",
      "type": ["string", "boolean", "number"]
    }
  },
  "required": ["ref", "value", "tabId"],
  "type": "object"
}
```

---

## mcp__claude-in-chrome__get_page_text

从页面提取原始文本内容，优先处理文章内容。适合阅读文章、博客文章或其他文本密集型页面。返回纯文本，不含 HTML 格式。如果你没有有效的标签页 ID，请先使用 tabs_context_mcp 获取可用标签页。

```json
{
  "properties": {
    "tabId": {
      "description": "Tab ID to extract text from. Must be a tab in the current group. Use tabs_context_mcp first if you don't have a valid tab ID.",
      "type": "number"
    }
  },
  "required": ["tabId"],
  "type": "object"
}
```

---

## mcp__claude-in-chrome__gif_creator

管理浏览器自动化会话的 GIF 录制和导出。控制何时开始/停止录制浏览器操作（点击、滚动、导航），然后导出为带有视觉叠加（点击指示器、操作标签、进度条、水印）的动画 GIF。所有操作限定在标签页组范围内。开始录制时，立即拍摄截图以捕获初始状态作为第一帧。停止录制时，立即拍摄截图以捕获最终状态作为最后一帧。对于导出，要么提供 coordinate 以拖放上传到页面元素，要么设置 download: true 以下载 GIF。

```json
{
  "properties": {
    "action": {
      "description": "Action to perform: 'start_recording' (begin capturing), 'stop_recording' (stop capturing but keep frames), 'export' (generate and export GIF), 'clear' (discard frames)",
      "enum": ["start_recording", "stop_recording", "export", "clear"],
      "type": "string"
    },
    "download": {
      "description": "Always set this to true for the 'export' action only. This causes the gif to be downloaded in the browser.",
      "type": "boolean"
    },
    "filename": {
      "description": "Optional filename for exported GIF (default: 'recording-[timestamp].gif'). For 'export' action only.",
      "type": "string"
    },
    "options": {
      "description": "Optional GIF enhancement options for 'export' action. Properties: showClickIndicators (bool), showDragPaths (bool), showActionLabels (bool), showProgressBar (bool), showWatermark (bool), quality (number 1-30). All default to true except quality (default: 10).",
      "properties": {
        "quality": {
          "description": "GIF compression quality, 1-30 (lower = better quality, slower encoding). Default: 10",
          "type": "number"
        },
        "showActionLabels": {
          "description": "Show black labels describing actions (default: true)",
          "type": "boolean"
        },
        "showClickIndicators": {
          "description": "Show orange circles at click locations (default: true)",
          "type": "boolean"
        },
        "showDragPaths": {
          "description": "Show red arrows for drag actions (default: true)",
          "type": "boolean"
        },
        "showProgressBar": {
          "description": "Show orange progress bar at bottom (default: true)",
          "type": "boolean"
        },
        "showWatermark": {
          "description": "Show Claude logo watermark (default: true)",
          "type": "boolean"
        }
      },
      "type": "object"
    },
    "tabId": {
      "description": "Tab ID to identify which tab group this operation applies to",
      "type": "number"
    }
  },
  "required": ["action", "tabId"],
  "type": "object"
}
```

---

## mcp__claude-in-chrome__javascript_tool

在当前页面的上下文中执行 JavaScript 代码。代码在页面的上下文中运行，可以与 DOM、window 对象和页面变量交互。返回最后一个表达式的结果或任何抛出的错误。如果你没有有效的标签页 ID，请先使用 tabs_context_mcp 获取可用标签页。

```json
{
  "properties": {
    "action": {
      "description": "Must be set to 'javascript_exec'",
      "type": "string"
    },
    "tabId": {
      "description": "Tab ID to execute the code in. Must be a tab in the current group. Use tabs_context_mcp first if you don't have a valid tab ID.",
      "type": "number"
    },
    "text": {
      "description": "The JavaScript code to execute. The code will be evaluated in the page context. The result of the last expression will be returned automatically. Do NOT use 'return' statements - just write the expression you want to evaluate (e.g., 'window.myData.value' not 'return window.myData.value'). You can access and modify the DOM, call page functions, and interact with page variables.",
      "type": "string"
    }
  },
  "required": ["action", "text", "tabId"],
  "type": "object"
}
```

---

## mcp__claude-in-chrome__list_connected_browsers

列出当前连接到此帐户的所有 Chrome 浏览器（扩展实例）。返回每个浏览器的 deviceId、显示名称、操作系统平台，以及它是否看起来在这台计算机上。在选择浏览器之前使用此工具向用户展示选项。在任何浏览器操作之前，你必须调用 AskUserQuestion 工具，提供一个将每个连接的浏览器作为单独选项列出的问题（使用显示名称作为标签，并在括号中包含 deviceId），再加上一个最终选项，标签精确为："Open a confirmation screen in every connected Chrome extension and let me select the right one there." 不要跳过任何连接的浏览器，也不要自己选择。如果用户选择了特定浏览器，使用该浏览器的 deviceId 调用 select_browser。如果用户选择了最终选项，调用 switch_browser——这会向每个连接的 Chrome 扩展发送确认提示，并等待用户在他们想要的那个上点击"Connect"；它还允许他们为该浏览器命名。

```json
{
  "properties": {},
  "required": [],
  "type": "object"
}
```

---

## mcp__claude-in-chrome__navigate

导航到 URL，或在浏览器历史记录中前进/后退。如果你没有有效的标签页 ID，请先使用 tabs_context_mcp 获取可用标签页。

```json
{
  "properties": {
    "tabId": {
      "description": "Tab ID to navigate. Must be a tab in the current group. Use tabs_context_mcp first if you don't have a valid tab ID.",
      "type": "number"
    },
    "url": {
      "description": "The URL to navigate to. Can be provided with or without protocol (defaults to https://). Use \"forward\" to go forward in history or \"back\" to go back in history.",
      "type": "string"
    }
  },
  "required": ["url", "tabId"],
  "type": "object"
}
```

---

## mcp__claude-in-chrome__read_console_messages

从特定标签页读取浏览器控制台消息（console.log、console.error、console.warn 等）。用于调试 JavaScript 错误、查看应用日志或了解浏览器控制台中发生的事情。仅返回当前域名的控制台消息。如果你没有有效的标签页 ID，请先使用 tabs_context_mcp 获取可用标签页。重要提示：始终提供模式来过滤消息——没有模式，你可能会得到太多不相关的消息。

```json
{
  "properties": {
    "clear": {
      "description": "If true, clear the console messages after reading to avoid duplicates on subsequent calls. Default is false.",
      "type": "boolean"
    },
    "limit": {
      "description": "Maximum number of messages to return. Defaults to 100. Increase only if you need more results.",
      "type": "number"
    },
    "onlyErrors": {
      "description": "If true, only return error and exception messages. Default is false (return all message types).",
      "type": "boolean"
    },
    "pattern": {
      "description": "Regex pattern to filter console messages. Only messages matching this pattern will be returned (e.g., 'error|warning' to find errors and warnings, 'MyApp' to filter app-specific logs). You should always provide a pattern to avoid getting too many irrelevant messages.",
      "type": "string"
    },
    "tabId": {
      "description": "Tab ID to read console messages from. Must be a tab in the current group. Use tabs_context_mcp first if you don't have a valid tab ID.",
      "type": "number"
    }
  },
  "required": ["tabId"],
  "type": "object"
}
```

---

## mcp__claude-in-chrome__read_network_requests

从特定标签页读取 HTTP 网络请求（XHR、Fetch、文档、图像等）。用于调试 API 调用、监控网络活动或了解页面发出的请求。返回当前页面发出的所有网络请求，包括跨域请求。当页面导航到不同域名时，请求会自动清除。如果你没有有效的标签页 ID，请先使用 tabs_context_mcp 获取可用标签页。

```json
{
  "properties": {
    "clear": {
      "description": "If true, clear the network requests after reading to avoid duplicates on subsequent calls. Default is false.",
      "type": "boolean"
    },
    "limit": {
      "description": "Maximum number of requests to return. Defaults to 100. Increase only if you need more results.",
      "type": "number"
    },
    "tabId": {
      "description": "Tab ID to read network requests from. Must be a tab in the current group. Use tabs_context_mcp first if you don't have a valid tab ID.",
      "type": "number"
    },
    "urlPattern": {
      "description": "Optional URL pattern to filter requests. Only requests whose URL contains this string will be returned (e.g., '/api/' to filter API calls, 'example.com' to filter by domain).",
      "type": "string"
    }
  },
  "required": ["tabId"],
  "type": "object"
}
```

---

## mcp__claude-in-chrome__read_page

获取页面上元素的可访问性树表示。默认返回所有元素，包括不可见元素。输出默认限制为 50000 个字符。如果输出超过此限制，你会收到错误，要求指定更小的深度或使用 ref_id 聚焦于特定元素。可选择仅过滤交互元素。如果你没有有效的标签页 ID，请先使用 tabs_context_mcp 获取可用标签页。

```json
{
  "properties": {
    "depth": {
      "description": "Maximum depth of the tree to traverse (default: 15). Use a smaller depth if output is too large.",
      "type": "number"
    },
    "filter": {
      "description": "Filter elements: \"interactive\" for buttons/links/inputs only, \"all\" for all elements including non-visible ones (default: all elements)",
      "enum": ["interactive", "all"],
      "type": "string"
    },
    "max_chars": {
      "description": "Maximum characters for output (default: 50000). Set to a higher value if your client can handle large outputs.",
      "type": "number"
    },
    "ref_id": {
      "description": "Reference ID of a parent element to read. Will return the specified element and all its children. Use this to focus on a specific part of the page when output is too large.",
      "type": "string"
    },
    "tabId": {
      "description": "Tab ID to read from. Must be a tab in the current group. Use tabs_context_mcp first if you don't have a valid tab ID.",
      "type": "number"
    }
  },
  "required": ["tabId"],
  "type": "object"
}
```

---

## mcp__claude-in-chrome__resize_window

将当前浏览器窗口调整到指定尺寸。用于测试响应式设计或设置特定屏幕大小。如果你没有有效的标签页 ID，请先使用 tabs_context_mcp 获取可用标签页。

```json
{
  "properties": {
    "height": {
      "description": "Target window height in pixels",
      "type": "number"
    },
    "tabId": {
      "description": "Tab ID to get the window for. Must be a tab in the current group. Use tabs_context_mcp first if you don't have a valid tab ID.",
      "type": "number"
    },
    "width": {
      "description": "Target window width in pixels",
      "type": "number"
    }
  },
  "required": ["width", "height", "tabId"],
  "type": "object"
}
```

---

## mcp__claude-in-chrome__select_browser

通过 deviceId 选择特定的 Chrome 浏览器进行浏览器自动化，无需广播配对请求。在用户从列表中选择了浏览器后，在 list_connected_browsers 之后使用此工具。

```json
{
  "properties": {
    "deviceId": {
      "description": "The deviceId from list_connected_browsers.",
      "type": "string"
    }
  },
  "required": ["deviceId"],
  "type": "object"
}
```

---

## mcp__claude-in-chrome__shortcuts_execute

通过在当前标签页的新侧面板窗口中运行快捷方式或工作流来执行它（快捷方式和工作流可以互换）。首先使用 shortcuts_list 查看可用的快捷方式。这会立即开始执行并返回——它不会等待完成。

```json
{
  "properties": {
    "command": {
      "description": "The command name of the shortcut to execute (e.g., 'debug', 'summarize'). Do not include the leading slash.",
      "type": "string"
    },
    "shortcutId": {
      "description": "The ID of the shortcut to execute",
      "type": "string"
    },
    "tabId": {
      "description": "Tab ID to execute the shortcut on. Must be a tab in the current group. Use tabs_context_mcp first if you don't have a valid tab ID.",
      "type": "number"
    }
  },
  "required": ["tabId"],
  "type": "object"
}
```

---

## mcp__claude-in-chrome__shortcuts_list

列出所有可用的快捷方式和工作流（快捷方式和工作流可以互换）。返回带有命令、描述以及是否为工作流的快捷方式。使用 shortcuts_execute 运行快捷方式或工作流。

```json
{
  "properties": {
    "tabId": {
      "description": "Tab ID to list shortcuts from. Must be a tab in the current group. Use tabs_context_mcp first if you don't have a valid tab ID.",
      "type": "number"
    }
  },
  "required": ["tabId"],
  "type": "object"
}
```

---

## mcp__claude-in-chrome__switch_browser

向每个安装了扩展的 Chrome 浏览器发送连接请求，并等待（最多 2 分钟）用户在他们想要使用的那一个上点击"Connect"。用户可以在连接时为浏览器命名。当用户想从 Chrome 内部自己选择浏览器而不是从列表中选择时使用此工具；否则优先使用带有已知 deviceId 的 select_browser。

```json
{
  "properties": {},
  "required": [],
  "type": "object"
}
```

---

## mcp__claude-in-chrome__tabs_close_mcp

通过 ID 关闭 MCP 标签页组中的标签页。用于清理你已完成操作的标签页。只有此会话组中的标签页可关闭；先调用 tabs_context_mcp 获取有效 ID。如果关闭了组的最后一个标签页，Chrome 会自动移除该组——下一次带 createIfEmpty 的 tabs_context_mcp 会重新开始。

```json
{
  "properties": {
    "tabId": {
      "description": "The ID of the tab to close. Must be in this session's tab group. Get valid IDs from tabs_context_mcp.",
      "type": "integer"
    }
  },
  "required": ["tabId"],
  "type": "object"
}
```

---

## mcp__claude-in-chrome__tabs_context_mcp

获取当前 MCP 标签页组的上下文信息。如果组存在，返回组内的所有标签页 ID。关键提示：在使用其他浏览器自动化工具之前，你必须至少获取一次上下文，以便了解存在哪些标签页。每个新对话应创建自己的新标签页（使用 tabs_create_mcp），而不是重用现有标签页，除非用户明确要求使用现有标签页。

```json
{
  "properties": {
    "createIfEmpty": {
      "description": "Creates a new MCP tab group if none exists, creates a new Window with a new tab group containing an empty tab (which can be used for this conversation). If a MCP tab group already exists, this parameter has no effect.",
      "type": "boolean"
    }
  },
  "required": [],
  "type": "object"
}
```

---

## mcp__claude-in-chrome__tabs_create_mcp

在 MCP 标签页组中创建一个新的空标签页。关键提示：在使用其他浏览器自动化工具之前，你必须至少使用 tabs_context_mcp 获取一次上下文，以便了解存在哪些标签页。

```json
{
  "properties": {},
  "required": [],
  "type": "object"
}
```

---

## mcp__claude-in-chrome__upload_image

上传之前捕获的截图或用户上传的图像到文件输入或拖放目标。支持两种方式：(1) ref——用于定位特定元素，特别是隐藏的文件输入，(2) coordinate——用于拖放到可见位置，如 Google Docs。提供 ref 或 coordinate 之一，不能同时提供。

```json
{
  "properties": {
    "coordinate": {
      "description": "Viewport coordinates [x, y] for drag & drop to a visible location. Use this for drag & drop targets like Google Docs. Provide either ref or coordinate, not both.",
      "items": {"type": "number"},
      "type": "array"
    },
    "filename": {
      "description": "Optional filename for the uploaded file (default: \"image.png\")",
      "type": "string"
    },
    "imageId": {
      "description": "ID of a previously captured screenshot (from the computer tool's screenshot action) or a user-uploaded image",
      "type": "string"
    },
    "ref": {
      "description": "Element reference ID from read_page or find tools (e.g., \"ref_1\", \"ref_2\"). Use this for file inputs (especially hidden ones) or specific elements. Provide either ref or coordinate, not both.",
      "type": "string"
    },
    "tabId": {
      "description": "Tab ID where the target element is located. This is where the image will be uploaded to.",
      "type": "number"
    }
  },
  "required": ["imageId", "tabId"],
  "type": "object"
}
```
